Merge remote-tracking branch 'remotes/ehabkost/tags/machine-next-pull-request' into...
[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 "qemu/osdep.h"
10 #include "qemu/int128.h"
11
12 /* clang doesn't support __noclone__ but it does have a mechanism for
13 * telling us this. We assume that if we don't have __has_attribute()
14 * then this is GCC and that GCC always supports __noclone__.
15 */
16 #if defined(__has_attribute)
17 #if !__has_attribute(__noclone__)
18 #define ATTRIBUTE_NOCLONE
19 #endif
20 #endif
21 #ifndef ATTRIBUTE_NOCLONE
22 #define ATTRIBUTE_NOCLONE __attribute__((__noclone__))
23 #endif
24
25 static uint32_t tests[8] = {
26 0x00000000, 0x00000001, 0x7FFFFFFE, 0x7FFFFFFF,
27 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF,
28 };
29
30 #define LOW 3ULL
31 #define HIGH (1ULL << 63)
32 #define MIDDLE (-1ULL & ~LOW & ~HIGH)
33
34 static uint64_t expand16(unsigned x)
35 {
36 return (x & LOW) | ((x & 4) ? MIDDLE : 0) | (x & 0x8000 ? HIGH : 0);
37 }
38
39 static Int128 expand(uint32_t x)
40 {
41 uint64_t l, h;
42 l = expand16(x & 65535);
43 h = expand16(x >> 16);
44 return (Int128) int128_make128(l, h);
45 };
46
47 static void test_and(void)
48 {
49 int i, j;
50
51 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
52 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
53 Int128 a = expand(tests[i]);
54 Int128 b = expand(tests[j]);
55 Int128 r = expand(tests[i] & tests[j]);
56 Int128 s = int128_and(a, b);
57 g_assert_cmpuint(int128_getlo(r), ==, int128_getlo(s));
58 g_assert_cmpuint(int128_gethi(r), ==, int128_gethi(s));
59 }
60 }
61 }
62
63 static void test_add(void)
64 {
65 int i, j;
66
67 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
68 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
69 Int128 a = expand(tests[i]);
70 Int128 b = expand(tests[j]);
71 Int128 r = expand(tests[i] + tests[j]);
72 Int128 s = int128_add(a, b);
73 g_assert_cmpuint(int128_getlo(r), ==, int128_getlo(s));
74 g_assert_cmpuint(int128_gethi(r), ==, int128_gethi(s));
75 }
76 }
77 }
78
79 static void test_sub(void)
80 {
81 int i, j;
82
83 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
84 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
85 Int128 a = expand(tests[i]);
86 Int128 b = expand(tests[j]);
87 Int128 r = expand(tests[i] - tests[j]);
88 Int128 s = int128_sub(a, b);
89 g_assert_cmpuint(int128_getlo(r), ==, int128_getlo(s));
90 g_assert_cmpuint(int128_gethi(r), ==, int128_gethi(s));
91 }
92 }
93 }
94
95 static void test_neg(void)
96 {
97 int i;
98
99 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
100 Int128 a = expand(tests[i]);
101 Int128 r = expand(-tests[i]);
102 Int128 s = int128_neg(a);
103 g_assert_cmpuint(int128_getlo(r), ==, int128_getlo(s));
104 g_assert_cmpuint(int128_gethi(r), ==, int128_gethi(s));
105 }
106 }
107
108 static void test_nz(void)
109 {
110 int i, j;
111
112 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
113 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
114 Int128 a = expand(tests[i]);
115 g_assert_cmpuint(int128_nz(a), ==, tests[i] != 0);
116 }
117 }
118 }
119
120 static void test_le(void)
121 {
122 int i, j;
123
124 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
125 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
126 /* Signed comparison */
127 int32_t a = (int32_t) tests[i];
128 int32_t b = (int32_t) tests[j];
129 g_assert_cmpuint(int128_le(expand(a), expand(b)), ==, a <= b);
130 }
131 }
132 }
133
134 static void test_lt(void)
135 {
136 int i, j;
137
138 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
139 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
140 /* Signed comparison */
141 int32_t a = (int32_t) tests[i];
142 int32_t b = (int32_t) tests[j];
143 g_assert_cmpuint(int128_lt(expand(a), expand(b)), ==, a < b);
144 }
145 }
146 }
147
148 static void test_ge(void)
149 {
150 int i, j;
151
152 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
153 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
154 /* Signed comparison */
155 int32_t a = (int32_t) tests[i];
156 int32_t b = (int32_t) tests[j];
157 g_assert_cmpuint(int128_ge(expand(a), expand(b)), ==, a >= b);
158 }
159 }
160 }
161
162 static void test_gt(void)
163 {
164 int i, j;
165
166 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
167 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
168 /* Signed comparison */
169 int32_t a = (int32_t) tests[i];
170 int32_t b = (int32_t) tests[j];
171 g_assert_cmpuint(int128_gt(expand(a), expand(b)), ==, a > b);
172 }
173 }
174 }
175
176 /* Make sure to test undefined behavior at runtime! */
177
178 static void __attribute__((__noinline__)) ATTRIBUTE_NOCLONE
179 test_rshift_one(uint32_t x, int n, uint64_t h, uint64_t l)
180 {
181 Int128 a = expand(x);
182 Int128 r = int128_rshift(a, n);
183 g_assert_cmpuint(int128_getlo(r), ==, l);
184 g_assert_cmpuint(int128_gethi(r), ==, h);
185 }
186
187 static void test_rshift(void)
188 {
189 test_rshift_one(0x00010000U, 64, 0x0000000000000000ULL, 0x0000000000000001ULL);
190 test_rshift_one(0x80010000U, 64, 0xFFFFFFFFFFFFFFFFULL, 0x8000000000000001ULL);
191 test_rshift_one(0x7FFE0000U, 64, 0x0000000000000000ULL, 0x7FFFFFFFFFFFFFFEULL);
192 test_rshift_one(0xFFFE0000U, 64, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFEULL);
193 test_rshift_one(0x00010000U, 60, 0x0000000000000000ULL, 0x0000000000000010ULL);
194 test_rshift_one(0x80010000U, 60, 0xFFFFFFFFFFFFFFF8ULL, 0x0000000000000010ULL);
195 test_rshift_one(0x00018000U, 60, 0x0000000000000000ULL, 0x0000000000000018ULL);
196 test_rshift_one(0x80018000U, 60, 0xFFFFFFFFFFFFFFF8ULL, 0x0000000000000018ULL);
197 test_rshift_one(0x7FFE0000U, 60, 0x0000000000000007ULL, 0xFFFFFFFFFFFFFFE0ULL);
198 test_rshift_one(0xFFFE0000U, 60, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFE0ULL);
199 test_rshift_one(0x7FFE8000U, 60, 0x0000000000000007ULL, 0xFFFFFFFFFFFFFFE8ULL);
200 test_rshift_one(0xFFFE8000U, 60, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFE8ULL);
201 test_rshift_one(0x00018000U, 0, 0x0000000000000001ULL, 0x8000000000000000ULL);
202 test_rshift_one(0x80018000U, 0, 0x8000000000000001ULL, 0x8000000000000000ULL);
203 test_rshift_one(0x7FFE0000U, 0, 0x7FFFFFFFFFFFFFFEULL, 0x0000000000000000ULL);
204 test_rshift_one(0xFFFE0000U, 0, 0xFFFFFFFFFFFFFFFEULL, 0x0000000000000000ULL);
205 test_rshift_one(0x7FFE8000U, 0, 0x7FFFFFFFFFFFFFFEULL, 0x8000000000000000ULL);
206 test_rshift_one(0xFFFE8000U, 0, 0xFFFFFFFFFFFFFFFEULL, 0x8000000000000000ULL);
207 }
208
209 int main(int argc, char **argv)
210 {
211 g_test_init(&argc, &argv, NULL);
212 g_test_add_func("/int128/int128_and", test_and);
213 g_test_add_func("/int128/int128_add", test_add);
214 g_test_add_func("/int128/int128_sub", test_sub);
215 g_test_add_func("/int128/int128_neg", test_neg);
216 g_test_add_func("/int128/int128_nz", test_nz);
217 g_test_add_func("/int128/int128_le", test_le);
218 g_test_add_func("/int128/int128_lt", test_lt);
219 g_test_add_func("/int128/int128_ge", test_ge);
220 g_test_add_func("/int128/int128_gt", test_gt);
221 g_test_add_func("/int128/int128_rshift", test_rshift);
222 return g_test_run();
223 }