1 /*
2 * fp-test.c - test QEMU's softfloat implementation using Berkeley's Testfloat
3 *
4 * Copyright (C) 2018, Emilio G. Cota <cota@braap.org>
5 *
6 * License: GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 *
9 * This file is derived from testfloat/source/testsoftfloat.c. Its copyright
10 * info follows:
11 *
12 * Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
13 * University of California. All rights reserved.
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions are met:
17 *
18 * 1. Redistributions of source code must retain the above copyright notice,
19 * this list of conditions, and the following disclaimer.
20 *
21 * 2. Redistributions in binary form must reproduce the above copyright notice,
22 * this list of conditions, and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 *
25 * 3. Neither the name of the University nor the names of its contributors may
26 * be used to endorse or promote products derived from this software without
27 * specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
30 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
31 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
32 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
33 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
35 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
36 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 */
40 #ifndef HW_POISON_H
41 #error Must define HW_POISON_H to work around TARGET_* poisoning
42 #endif
43
44 #include "qemu/osdep.h"
45 #include "qemu/cutils.h"
46 #include <math.h>
47 #include "fpu/softfloat.h"
48 #include "platform.h"
49
50 #include "fail.h"
51 #include "slowfloat.h"
52 #include "functions.h"
53 #include "genCases.h"
54 #include "verCases.h"
55 #include "writeCase.h"
56 #include "testLoops.h"
57
58 typedef float16_t (*abz_f16)(float16_t, float16_t);
59 typedef bool (*ab_f16_z_bool)(float16_t, float16_t);
60 typedef float32_t (*abz_f32)(float32_t, float32_t);
61 typedef bool (*ab_f32_z_bool)(float32_t, float32_t);
62 typedef float64_t (*abz_f64)(float64_t, float64_t);
63 typedef bool (*ab_f64_z_bool)(float64_t, float64_t);
64 typedef void (*abz_extF80M)(const extFloat80_t *, const extFloat80_t *,
65 extFloat80_t *);
66 typedef bool (*ab_extF80M_z_bool)(const extFloat80_t *, const extFloat80_t *);
67 typedef void (*abz_f128M)(const float128_t *, const float128_t *, float128_t *);
68 typedef bool (*ab_f128M_z_bool)(const float128_t *, const float128_t *);
69
70 static const char * const round_mode_names[] = {
71 [ROUND_NEAR_EVEN] = "even",
72 [ROUND_MINMAG] = "zero",
73 [ROUND_MIN] = "down",
74 [ROUND_MAX] = "up",
75 [ROUND_NEAR_MAXMAG] = "tieaway",
76 [ROUND_ODD] = "odd",
77 };
78 static unsigned int *test_ops;
79 static unsigned int n_test_ops;
80 static unsigned int n_max_errors = 20;
81 static unsigned int test_round_mode = ROUND_NEAR_EVEN;
82 static unsigned int *round_modes;
83 static unsigned int n_round_modes;
84 static int test_level = 1;
85 static uint8_t slow_init_flags;
86 static uint8_t qemu_init_flags;
87
88 /* qemu softfloat status */
89 static float_status qsf;
90
91 static const char commands_string[] =
92 "operations:\n"
93 " <int>_to_<float> <float>_add <float>_eq\n"
94 " <float>_to_<int> <float>_sub <float>_le\n"
95 " <float>_to_<int>_r_minMag <float>_mul <float>_lt\n"
96 " <float>_to_<float> <float>_mulAdd <float>_eq_signaling\n"
97 " <float>_roundToInt <float>_div <float>_le_quiet\n"
98 " <float>_rem <float>_lt_quiet\n"
99 " <float>_sqrt\n"
100 " Where <int>: ui32, ui64, i32, i64\n"
101 " <float>: f16, f32, f64, extF80, f128\n"
102 " If no operation is provided, all the above are tested\n"
103 "options:\n"
104 " -e = max error count per test. Default: 20. Set no limit with 0\n"
105 " -f = initial FP exception flags (vioux). Default: none\n"
106 " -l = thoroughness level (1 (default), 2)\n"
107 " -r = rounding mode (even (default), zero, down, up, tieaway, odd)\n"
108 " Set to 'all' to test all rounding modes, if applicable\n"
109 " -s = stop when a test fails\n"
110 " -q = minimise noise when testing, just show each function being tested";
111
usage_complete(int argc,char * argv[])112 static void usage_complete(int argc, char *argv[])
113 {
114 fprintf(stderr, "Usage: %s [options] [operation1 ...]\n", argv[0]);
115 fprintf(stderr, "%s\n", commands_string);
116 exit(EXIT_FAILURE);
117 }
118
119 /* keep wrappers separate but do not bother defining headers for all of them */
120 #include "wrap.c.inc"
121
not_implemented(void)122 static void not_implemented(void)
123 {
124 fprintf(stderr, "Not implemented.\n");
125 }
126
is_allowed(unsigned op,int rmode)127 static bool is_allowed(unsigned op, int rmode)
128 {
129 /* odd has not been implemented for any 80-bit ops */
130 if (rmode == softfloat_round_odd) {
131 switch (op) {
132 case EXTF80_TO_UI32:
133 case EXTF80_TO_UI64:
134 case EXTF80_TO_I32:
135 case EXTF80_TO_I64:
136 case EXTF80_TO_UI32_R_MINMAG:
137 case EXTF80_TO_UI64_R_MINMAG:
138 case EXTF80_TO_I32_R_MINMAG:
139 case EXTF80_TO_I64_R_MINMAG:
140 case EXTF80_TO_F16:
141 case EXTF80_TO_F32:
142 case EXTF80_TO_F64:
143 case EXTF80_TO_F128:
144 case EXTF80_ROUNDTOINT:
145 case EXTF80_ADD:
146 case EXTF80_SUB:
147 case EXTF80_MUL:
148 case EXTF80_DIV:
149 case EXTF80_REM:
150 case EXTF80_SQRT:
151 case EXTF80_EQ:
152 case EXTF80_LE:
153 case EXTF80_LT:
154 case EXTF80_EQ_SIGNALING:
155 case EXTF80_LE_QUIET:
156 case EXTF80_LT_QUIET:
157 case UI32_TO_EXTF80:
158 case UI64_TO_EXTF80:
159 case I32_TO_EXTF80:
160 case I64_TO_EXTF80:
161 case F16_TO_EXTF80:
162 case F32_TO_EXTF80:
163 case F64_TO_EXTF80:
164 case F128_TO_EXTF80:
165 return false;
166 }
167 }
168 return true;
169 }
170
do_testfloat(int op,int rmode,bool exact)171 static void do_testfloat(int op, int rmode, bool exact)
172 {
173 abz_f16 true_abz_f16;
174 abz_f16 subj_abz_f16;
175 ab_f16_z_bool true_f16_z_bool;
176 ab_f16_z_bool subj_f16_z_bool;
177 abz_f32 true_abz_f32;
178 abz_f32 subj_abz_f32;
179 ab_f32_z_bool true_ab_f32_z_bool;
180 ab_f32_z_bool subj_ab_f32_z_bool;
181 abz_f64 true_abz_f64;
182 abz_f64 subj_abz_f64;
183 ab_f64_z_bool true_ab_f64_z_bool;
184 ab_f64_z_bool subj_ab_f64_z_bool;
185 abz_extF80M true_abz_extF80M;
186 abz_extF80M subj_abz_extF80M;
187 ab_extF80M_z_bool true_ab_extF80M_z_bool;
188 ab_extF80M_z_bool subj_ab_extF80M_z_bool;
189 abz_f128M true_abz_f128M;
190 abz_f128M subj_abz_f128M;
191 ab_f128M_z_bool true_ab_f128M_z_bool;
192 ab_f128M_z_bool subj_ab_f128M_z_bool;
193
194 if (verCases_verbosity) {
195 fputs(">> Testing ", stderr);
196 verCases_writeFunctionName(stderr);
197 fputs("\n", stderr);
198 }
199
200 if (!is_allowed(op, rmode)) {
201 not_implemented();
202 return;
203 }
204
205 switch (op) {
206 case UI32_TO_F16:
207 test_a_ui32_z_f16(slow_ui32_to_f16, qemu_ui32_to_f16);
208 break;
209 case UI32_TO_F32:
210 test_a_ui32_z_f32(slow_ui32_to_f32, qemu_ui32_to_f32);
211 break;
212 case UI32_TO_F64:
213 test_a_ui32_z_f64(slow_ui32_to_f64, qemu_ui32_to_f64);
214 break;
215 case UI32_TO_EXTF80:
216 not_implemented();
217 break;
218 case UI32_TO_F128:
219 not_implemented();
220 break;
221 case UI64_TO_F16:
222 test_a_ui64_z_f16(slow_ui64_to_f16, qemu_ui64_to_f16);
223 break;
224 case UI64_TO_F32:
225 test_a_ui64_z_f32(slow_ui64_to_f32, qemu_ui64_to_f32);
226 break;
227 case UI64_TO_F64:
228 test_a_ui64_z_f64(slow_ui64_to_f64, qemu_ui64_to_f64);
229 break;
230 case UI64_TO_EXTF80:
231 not_implemented();
232 break;
233 case UI64_TO_F128:
234 test_a_ui64_z_f128(slow_ui64_to_f128M, qemu_ui64_to_f128M);
235 break;
236 case I32_TO_F16:
237 test_a_i32_z_f16(slow_i32_to_f16, qemu_i32_to_f16);
238 break;
239 case I32_TO_F32:
240 test_a_i32_z_f32(slow_i32_to_f32, qemu_i32_to_f32);
241 break;
242 case I32_TO_F64:
243 test_a_i32_z_f64(slow_i32_to_f64, qemu_i32_to_f64);
244 break;
245 case I32_TO_EXTF80:
246 test_a_i32_z_extF80(slow_i32_to_extF80M, qemu_i32_to_extF80M);
247 break;
248 case I32_TO_F128:
249 test_a_i32_z_f128(slow_i32_to_f128M, qemu_i32_to_f128M);
250 break;
251 case I64_TO_F16:
252 test_a_i64_z_f16(slow_i64_to_f16, qemu_i64_to_f16);
253 break;
254 case I64_TO_F32:
255 test_a_i64_z_f32(slow_i64_to_f32, qemu_i64_to_f32);
256 break;
257 case I64_TO_F64:
258 test_a_i64_z_f64(slow_i64_to_f64, qemu_i64_to_f64);
259 break;
260 case I64_TO_EXTF80:
261 test_a_i64_z_extF80(slow_i64_to_extF80M, qemu_i64_to_extF80M);
262 break;
263 case I64_TO_F128:
264 test_a_i64_z_f128(slow_i64_to_f128M, qemu_i64_to_f128M);
265 break;
266 case F16_TO_UI32:
267 test_a_f16_z_ui32_rx(slow_f16_to_ui32, qemu_f16_to_ui32, rmode, exact);
268 break;
269 case F16_TO_UI64:
270 test_a_f16_z_ui64_rx(slow_f16_to_ui64, qemu_f16_to_ui64, rmode, exact);
271 break;
272 case F16_TO_I32:
273 test_a_f16_z_i32_rx(slow_f16_to_i32, qemu_f16_to_i32, rmode, exact);
274 break;
275 case F16_TO_I64:
276 test_a_f16_z_i64_rx(slow_f16_to_i64, qemu_f16_to_i64, rmode, exact);
277 break;
278 case F16_TO_UI32_R_MINMAG:
279 test_a_f16_z_ui32_x(slow_f16_to_ui32_r_minMag,
280 qemu_f16_to_ui32_r_minMag, exact);
281 break;
282 case F16_TO_UI64_R_MINMAG:
283 test_a_f16_z_ui64_x(slow_f16_to_ui64_r_minMag,
284 qemu_f16_to_ui64_r_minMag, exact);
285 break;
286 case F16_TO_I32_R_MINMAG:
287 test_a_f16_z_i32_x(slow_f16_to_i32_r_minMag, qemu_f16_to_i32_r_minMag,
288 exact);
289 break;
290 case F16_TO_I64_R_MINMAG:
291 test_a_f16_z_i64_x(slow_f16_to_i64_r_minMag, qemu_f16_to_i64_r_minMag,
292 exact);
293 break;
294 case F16_TO_F32:
295 test_a_f16_z_f32(slow_f16_to_f32, qemu_f16_to_f32);
296 break;
297 case F16_TO_F64:
298 test_a_f16_z_f64(slow_f16_to_f64, qemu_f16_to_f64);
299 break;
300 case F16_TO_EXTF80:
301 not_implemented();
302 break;
303 case F16_TO_F128:
304 not_implemented();
305 break;
306 case F16_ROUNDTOINT:
307 test_az_f16_rx(slow_f16_roundToInt, qemu_f16_roundToInt, rmode, exact);
308 break;
309 case F16_ADD:
310 true_abz_f16 = slow_f16_add;
311 subj_abz_f16 = qemu_f16_add;
312 goto test_abz_f16;
313 case F16_SUB:
314 true_abz_f16 = slow_f16_sub;
315 subj_abz_f16 = qemu_f16_sub;
316 goto test_abz_f16;
317 case F16_MUL:
318 true_abz_f16 = slow_f16_mul;
319 subj_abz_f16 = qemu_f16_mul;
320 goto test_abz_f16;
321 case F16_DIV:
322 true_abz_f16 = slow_f16_div;
323 subj_abz_f16 = qemu_f16_div;
324 goto test_abz_f16;
325 case F16_REM:
326 not_implemented();
327 break;
328 test_abz_f16:
329 test_abz_f16(true_abz_f16, subj_abz_f16);
330 break;
331 case F16_MULADD:
332 test_abcz_f16(slow_f16_mulAdd, qemu_f16_mulAdd);
333 break;
334 case F16_SQRT:
335 test_az_f16(slow_f16_sqrt, qemu_f16_sqrt);
336 break;
337 case F16_EQ:
338 true_f16_z_bool = slow_f16_eq;
339 subj_f16_z_bool = qemu_f16_eq;
340 goto test_ab_f16_z_bool;
341 case F16_LE:
342 true_f16_z_bool = slow_f16_le;
343 subj_f16_z_bool = qemu_f16_le;
344 goto test_ab_f16_z_bool;
345 case F16_LT:
346 true_f16_z_bool = slow_f16_lt;
347 subj_f16_z_bool = qemu_f16_lt;
348 goto test_ab_f16_z_bool;
349 case F16_EQ_SIGNALING:
350 true_f16_z_bool = slow_f16_eq_signaling;
351 subj_f16_z_bool = qemu_f16_eq_signaling;
352 goto test_ab_f16_z_bool;
353 case F16_LE_QUIET:
354 true_f16_z_bool = slow_f16_le_quiet;
355 subj_f16_z_bool = qemu_f16_le_quiet;
356 goto test_ab_f16_z_bool;
357 case F16_LT_QUIET:
358 true_f16_z_bool = slow_f16_lt_quiet;
359 subj_f16_z_bool = qemu_f16_lt_quiet;
360 test_ab_f16_z_bool:
361 test_ab_f16_z_bool(true_f16_z_bool, subj_f16_z_bool);
362 break;
363 case F32_TO_UI32:
364 test_a_f32_z_ui32_rx(slow_f32_to_ui32, qemu_f32_to_ui32, rmode, exact);
365 break;
366 case F32_TO_UI64:
367 test_a_f32_z_ui64_rx(slow_f32_to_ui64, qemu_f32_to_ui64, rmode, exact);
368 break;
369 case F32_TO_I32:
370 test_a_f32_z_i32_rx(slow_f32_to_i32, qemu_f32_to_i32, rmode, exact);
371 break;
372 case F32_TO_I64:
373 test_a_f32_z_i64_rx(slow_f32_to_i64, qemu_f32_to_i64, rmode, exact);
374 break;
375 case F32_TO_UI32_R_MINMAG:
376 test_a_f32_z_ui32_x(slow_f32_to_ui32_r_minMag,
377 qemu_f32_to_ui32_r_minMag, exact);
378 break;
379 case F32_TO_UI64_R_MINMAG:
380 test_a_f32_z_ui64_x(slow_f32_to_ui64_r_minMag,
381 qemu_f32_to_ui64_r_minMag, exact);
382 break;
383 case F32_TO_I32_R_MINMAG:
384 test_a_f32_z_i32_x(slow_f32_to_i32_r_minMag, qemu_f32_to_i32_r_minMag,
385 exact);
386 break;
387 case F32_TO_I64_R_MINMAG:
388 test_a_f32_z_i64_x(slow_f32_to_i64_r_minMag, qemu_f32_to_i64_r_minMag,
389 exact);
390 break;
391 case F32_TO_F16:
392 test_a_f32_z_f16(slow_f32_to_f16, qemu_f32_to_f16);
393 break;
394 case F32_TO_F64:
395 test_a_f32_z_f64(slow_f32_to_f64, qemu_f32_to_f64);
396 break;
397 case F32_TO_EXTF80:
398 test_a_f32_z_extF80(slow_f32_to_extF80M, qemu_f32_to_extF80M);
399 break;
400 case F32_TO_F128:
401 test_a_f32_z_f128(slow_f32_to_f128M, qemu_f32_to_f128M);
402 break;
403 case F32_ROUNDTOINT:
404 test_az_f32_rx(slow_f32_roundToInt, qemu_f32_roundToInt, rmode, exact);
405 break;
406 case F32_ADD:
407 true_abz_f32 = slow_f32_add;
408 subj_abz_f32 = qemu_f32_add;
409 goto test_abz_f32;
410 case F32_SUB:
411 true_abz_f32 = slow_f32_sub;
412 subj_abz_f32 = qemu_f32_sub;
413 goto test_abz_f32;
414 case F32_MUL:
415 true_abz_f32 = slow_f32_mul;
416 subj_abz_f32 = qemu_f32_mul;
417 goto test_abz_f32;
418 case F32_DIV:
419 true_abz_f32 = slow_f32_div;
420 subj_abz_f32 = qemu_f32_div;
421 goto test_abz_f32;
422 case F32_REM:
423 true_abz_f32 = slow_f32_rem;
424 subj_abz_f32 = qemu_f32_rem;
425 test_abz_f32:
426 test_abz_f32(true_abz_f32, subj_abz_f32);
427 break;
428 case F32_MULADD:
429 test_abcz_f32(slow_f32_mulAdd, qemu_f32_mulAdd);
430 break;
431 case F32_SQRT:
432 test_az_f32(slow_f32_sqrt, qemu_f32_sqrt);
433 break;
434 case F32_EQ:
435 true_ab_f32_z_bool = slow_f32_eq;
436 subj_ab_f32_z_bool = qemu_f32_eq;
437 goto test_ab_f32_z_bool;
438 case F32_LE:
439 true_ab_f32_z_bool = slow_f32_le;
440 subj_ab_f32_z_bool = qemu_f32_le;
441 goto test_ab_f32_z_bool;
442 case F32_LT:
443 true_ab_f32_z_bool = slow_f32_lt;
444 subj_ab_f32_z_bool = qemu_f32_lt;
445 goto test_ab_f32_z_bool;
446 case F32_EQ_SIGNALING:
447 true_ab_f32_z_bool = slow_f32_eq_signaling;
448 subj_ab_f32_z_bool = qemu_f32_eq_signaling;
449 goto test_ab_f32_z_bool;
450 case F32_LE_QUIET:
451 true_ab_f32_z_bool = slow_f32_le_quiet;
452 subj_ab_f32_z_bool = qemu_f32_le_quiet;
453 goto test_ab_f32_z_bool;
454 case F32_LT_QUIET:
455 true_ab_f32_z_bool = slow_f32_lt_quiet;
456 subj_ab_f32_z_bool = qemu_f32_lt_quiet;
457 test_ab_f32_z_bool:
458 test_ab_f32_z_bool(true_ab_f32_z_bool, subj_ab_f32_z_bool);
459 break;
460 case F64_TO_UI32:
461 test_a_f64_z_ui32_rx(slow_f64_to_ui32, qemu_f64_to_ui32, rmode, exact);
462 break;
463 case F64_TO_UI64:
464 test_a_f64_z_ui64_rx(slow_f64_to_ui64, qemu_f64_to_ui64, rmode, exact);
465 break;
466 case F64_TO_I32:
467 test_a_f64_z_i32_rx(slow_f64_to_i32, qemu_f64_to_i32, rmode, exact);
468 break;
469 case F64_TO_I64:
470 test_a_f64_z_i64_rx(slow_f64_to_i64, qemu_f64_to_i64, rmode, exact);
471 break;
472 case F64_TO_UI32_R_MINMAG:
473 test_a_f64_z_ui32_x(slow_f64_to_ui32_r_minMag,
474 qemu_f64_to_ui32_r_minMag, exact);
475 break;
476 case F64_TO_UI64_R_MINMAG:
477 test_a_f64_z_ui64_x(slow_f64_to_ui64_r_minMag,
478 qemu_f64_to_ui64_r_minMag, exact);
479 break;
480 case F64_TO_I32_R_MINMAG:
481 test_a_f64_z_i32_x(slow_f64_to_i32_r_minMag, qemu_f64_to_i32_r_minMag,
482 exact);
483 break;
484 case F64_TO_I64_R_MINMAG:
485 test_a_f64_z_i64_x(slow_f64_to_i64_r_minMag, qemu_f64_to_i64_r_minMag,
486 exact);
487 break;
488 case F64_TO_F16:
489 test_a_f64_z_f16(slow_f64_to_f16, qemu_f64_to_f16);
490 break;
491 case F64_TO_F32:
492 test_a_f64_z_f32(slow_f64_to_f32, qemu_f64_to_f32);
493 break;
494 case F64_TO_EXTF80:
495 test_a_f64_z_extF80(slow_f64_to_extF80M, qemu_f64_to_extF80M);
496 break;
497 case F64_TO_F128:
498 test_a_f64_z_f128(slow_f64_to_f128M, qemu_f64_to_f128M);
499 break;
500 case F64_ROUNDTOINT:
501 test_az_f64_rx(slow_f64_roundToInt, qemu_f64_roundToInt, rmode, exact);
502 break;
503 case F64_ADD:
504 true_abz_f64 = slow_f64_add;
505 subj_abz_f64 = qemu_f64_add;
506 goto test_abz_f64;
507 case F64_SUB:
508 true_abz_f64 = slow_f64_sub;
509 subj_abz_f64 = qemu_f64_sub;
510 goto test_abz_f64;
511 case F64_MUL:
512 true_abz_f64 = slow_f64_mul;
513 subj_abz_f64 = qemu_f64_mul;
514 goto test_abz_f64;
515 case F64_DIV:
516 true_abz_f64 = slow_f64_div;
517 subj_abz_f64 = qemu_f64_div;
518 goto test_abz_f64;
519 case F64_REM:
520 true_abz_f64 = slow_f64_rem;
521 subj_abz_f64 = qemu_f64_rem;
522 test_abz_f64:
523 test_abz_f64(true_abz_f64, subj_abz_f64);
524 break;
525 case F64_MULADD:
526 test_abcz_f64(slow_f64_mulAdd, qemu_f64_mulAdd);
527 break;
528 case F64_SQRT:
529 test_az_f64(slow_f64_sqrt, qemu_f64_sqrt);
530 break;
531 case F64_EQ:
532 true_ab_f64_z_bool = slow_f64_eq;
533 subj_ab_f64_z_bool = qemu_f64_eq;
534 goto test_ab_f64_z_bool;
535 case F64_LE:
536 true_ab_f64_z_bool = slow_f64_le;
537 subj_ab_f64_z_bool = qemu_f64_le;
538 goto test_ab_f64_z_bool;
539 case F64_LT:
540 true_ab_f64_z_bool = slow_f64_lt;
541 subj_ab_f64_z_bool = qemu_f64_lt;
542 goto test_ab_f64_z_bool;
543 case F64_EQ_SIGNALING:
544 true_ab_f64_z_bool = slow_f64_eq_signaling;
545 subj_ab_f64_z_bool = qemu_f64_eq_signaling;
546 goto test_ab_f64_z_bool;
547 case F64_LE_QUIET:
548 true_ab_f64_z_bool = slow_f64_le_quiet;
549 subj_ab_f64_z_bool = qemu_f64_le_quiet;
550 goto test_ab_f64_z_bool;
551 case F64_LT_QUIET:
552 true_ab_f64_z_bool = slow_f64_lt_quiet;
553 subj_ab_f64_z_bool = qemu_f64_lt_quiet;
554 test_ab_f64_z_bool:
555 test_ab_f64_z_bool(true_ab_f64_z_bool, subj_ab_f64_z_bool);
556 break;
557 case EXTF80_TO_UI32:
558 not_implemented();
559 break;
560 case EXTF80_TO_UI64:
561 not_implemented();
562 break;
563 case EXTF80_TO_I32:
564 test_a_extF80_z_i32_rx(slow_extF80M_to_i32, qemu_extF80M_to_i32, rmode,
565 exact);
566 break;
567 case EXTF80_TO_I64:
568 test_a_extF80_z_i64_rx(slow_extF80M_to_i64, qemu_extF80M_to_i64, rmode,
569 exact);
570 break;
571 case EXTF80_TO_UI32_R_MINMAG:
572 not_implemented();
573 break;
574 case EXTF80_TO_UI64_R_MINMAG:
575 not_implemented();
576 break;
577 case EXTF80_TO_I32_R_MINMAG:
578 test_a_extF80_z_i32_x(slow_extF80M_to_i32_r_minMag,
579 qemu_extF80M_to_i32_r_minMag, exact);
580 break;
581 case EXTF80_TO_I64_R_MINMAG:
582 test_a_extF80_z_i64_x(slow_extF80M_to_i64_r_minMag,
583 qemu_extF80M_to_i64_r_minMag, exact);
584 break;
585 case EXTF80_TO_F16:
586 not_implemented();
587 break;
588 case EXTF80_TO_F32:
589 test_a_extF80_z_f32(slow_extF80M_to_f32, qemu_extF80M_to_f32);
590 break;
591 case EXTF80_TO_F64:
592 test_a_extF80_z_f64(slow_extF80M_to_f64, qemu_extF80M_to_f64);
593 break;
594 case EXTF80_TO_F128:
595 test_a_extF80_z_f128(slow_extF80M_to_f128M, qemu_extF80M_to_f128M);
596 break;
597 case EXTF80_ROUNDTOINT:
598 test_az_extF80_rx(slow_extF80M_roundToInt, qemu_extF80M_roundToInt,
599 rmode, exact);
600 break;
601 case EXTF80_ADD:
602 true_abz_extF80M = slow_extF80M_add;
603 subj_abz_extF80M = qemu_extF80M_add;
604 goto test_abz_extF80;
605 case EXTF80_SUB:
606 true_abz_extF80M = slow_extF80M_sub;
607 subj_abz_extF80M = qemu_extF80M_sub;
608 goto test_abz_extF80;
609 case EXTF80_MUL:
610 true_abz_extF80M = slow_extF80M_mul;
611 subj_abz_extF80M = qemu_extF80M_mul;
612 goto test_abz_extF80;
613 case EXTF80_DIV:
614 true_abz_extF80M = slow_extF80M_div;
615 subj_abz_extF80M = qemu_extF80M_div;
616 goto test_abz_extF80;
617 case EXTF80_REM:
618 true_abz_extF80M = slow_extF80M_rem;
619 subj_abz_extF80M = qemu_extF80M_rem;
620 test_abz_extF80:
621 test_abz_extF80(true_abz_extF80M, subj_abz_extF80M);
622 break;
623 case EXTF80_SQRT:
624 test_az_extF80(slow_extF80M_sqrt, qemu_extF80M_sqrt);
625 break;
626 case EXTF80_EQ:
627 true_ab_extF80M_z_bool = slow_extF80M_eq;
628 subj_ab_extF80M_z_bool = qemu_extF80M_eq;
629 goto test_ab_extF80_z_bool;
630 case EXTF80_LE:
631 true_ab_extF80M_z_bool = slow_extF80M_le;
632 subj_ab_extF80M_z_bool = qemu_extF80M_le;
633 goto test_ab_extF80_z_bool;
634 case EXTF80_LT:
635 true_ab_extF80M_z_bool = slow_extF80M_lt;
636 subj_ab_extF80M_z_bool = qemu_extF80M_lt;
637 goto test_ab_extF80_z_bool;
638 case EXTF80_EQ_SIGNALING:
639 true_ab_extF80M_z_bool = slow_extF80M_eq_signaling;
640 subj_ab_extF80M_z_bool = qemu_extF80M_eq_signaling;
641 goto test_ab_extF80_z_bool;
642 case EXTF80_LE_QUIET:
643 true_ab_extF80M_z_bool = slow_extF80M_le_quiet;
644 subj_ab_extF80M_z_bool = qemu_extF80M_le_quiet;
645 goto test_ab_extF80_z_bool;
646 case EXTF80_LT_QUIET:
647 true_ab_extF80M_z_bool = slow_extF80M_lt_quiet;
648 subj_ab_extF80M_z_bool = qemu_extF80M_lt_quiet;
649 test_ab_extF80_z_bool:
650 test_ab_extF80_z_bool(true_ab_extF80M_z_bool, subj_ab_extF80M_z_bool);
651 break;
652 case F128_TO_UI32:
653 test_a_f128_z_ui32_rx(slow_f128M_to_ui32, qemu_f128M_to_ui32, rmode,
654 exact);
655 break;
656 case F128_TO_UI64:
657 test_a_f128_z_ui64_rx(slow_f128M_to_ui64, qemu_f128M_to_ui64, rmode,
658 exact);
659 break;
660 case F128_TO_I32:
661 test_a_f128_z_i32_rx(slow_f128M_to_i32, qemu_f128M_to_i32, rmode,
662 exact);
663 break;
664 case F128_TO_I64:
665 test_a_f128_z_i64_rx(slow_f128M_to_i64, qemu_f128M_to_i64, rmode,
666 exact);
667 break;
668 case F128_TO_UI32_R_MINMAG:
669 test_a_f128_z_ui32_x(slow_f128M_to_ui32_r_minMag,
670 qemu_f128M_to_ui32_r_minMag, exact);
671 break;
672 case F128_TO_UI64_R_MINMAG:
673 test_a_f128_z_ui64_x(slow_f128M_to_ui64_r_minMag,
674 qemu_f128M_to_ui64_r_minMag, exact);
675 break;
676 case F128_TO_I32_R_MINMAG:
677 test_a_f128_z_i32_x(slow_f128M_to_i32_r_minMag,
678 qemu_f128M_to_i32_r_minMag, exact);
679 break;
680 case F128_TO_I64_R_MINMAG:
681 test_a_f128_z_i64_x(slow_f128M_to_i64_r_minMag,
682 qemu_f128M_to_i64_r_minMag, exact);
683 break;
684 case F128_TO_F16:
685 not_implemented();
686 break;
687 case F128_TO_F32:
688 test_a_f128_z_f32(slow_f128M_to_f32, qemu_f128M_to_f32);
689 break;
690 case F128_TO_F64:
691 test_a_f128_z_f64(slow_f128M_to_f64, qemu_f128M_to_f64);
692 break;
693 case F128_TO_EXTF80:
694 test_a_f128_z_extF80(slow_f128M_to_extF80M, qemu_f128M_to_extF80M);
695 break;
696 case F128_ROUNDTOINT:
697 test_az_f128_rx(slow_f128M_roundToInt, qemu_f128M_roundToInt, rmode,
698 exact);
699 break;
700 case F128_ADD:
701 true_abz_f128M = slow_f128M_add;
702 subj_abz_f128M = qemu_f128M_add;
703 goto test_abz_f128;
704 case F128_SUB:
705 true_abz_f128M = slow_f128M_sub;
706 subj_abz_f128M = qemu_f128M_sub;
707 goto test_abz_f128;
708 case F128_MUL:
709 true_abz_f128M = slow_f128M_mul;
710 subj_abz_f128M = qemu_f128M_mul;
711 goto test_abz_f128;
712 case F128_DIV:
713 true_abz_f128M = slow_f128M_div;
714 subj_abz_f128M = qemu_f128M_div;
715 goto test_abz_f128;
716 case F128_REM:
717 true_abz_f128M = slow_f128M_rem;
718 subj_abz_f128M = qemu_f128M_rem;
719 test_abz_f128:
720 test_abz_f128(true_abz_f128M, subj_abz_f128M);
721 break;
722 case F128_MULADD:
723 test_abcz_f128(slow_f128M_mulAdd, qemu_f128M_mulAdd);
724 break;
725 case F128_SQRT:
726 test_az_f128(slow_f128M_sqrt, qemu_f128M_sqrt);
727 break;
728 case F128_EQ:
729 true_ab_f128M_z_bool = slow_f128M_eq;
730 subj_ab_f128M_z_bool = qemu_f128M_eq;
731 goto test_ab_f128_z_bool;
732 case F128_LE:
733 true_ab_f128M_z_bool = slow_f128M_le;
734 subj_ab_f128M_z_bool = qemu_f128M_le;
735 goto test_ab_f128_z_bool;
736 case F128_LT:
737 true_ab_f128M_z_bool = slow_f128M_lt;
738 subj_ab_f128M_z_bool = qemu_f128M_lt;
739 goto test_ab_f128_z_bool;
740 case F128_EQ_SIGNALING:
741 true_ab_f128M_z_bool = slow_f128M_eq_signaling;
742 subj_ab_f128M_z_bool = qemu_f128M_eq_signaling;
743 goto test_ab_f128_z_bool;
744 case F128_LE_QUIET:
745 true_ab_f128M_z_bool = slow_f128M_le_quiet;
746 subj_ab_f128M_z_bool = qemu_f128M_le_quiet;
747 goto test_ab_f128_z_bool;
748 case F128_LT_QUIET:
749 true_ab_f128M_z_bool = slow_f128M_lt_quiet;
750 subj_ab_f128M_z_bool = qemu_f128M_lt_quiet;
751 test_ab_f128_z_bool:
752 test_ab_f128_z_bool(true_ab_f128M_z_bool, subj_ab_f128M_z_bool);
753 break;
754 }
755 if ((verCases_errorStop && verCases_anyErrors)) {
756 verCases_exitWithStatus();
757 }
758 }
759
test_name_to_op(const char * arg)760 static unsigned int test_name_to_op(const char *arg)
761 {
762 unsigned int i;
763
764 /* counting begins at 1 */
765 for (i = 1; i < NUM_FUNCTIONS; i++) {
766 const char *name = functionInfos[i].namePtr;
767
768 if (name && !strcmp(name, arg)) {
769 return i;
770 }
771 }
772 return 0;
773 }
774
round_name_to_mode(const char * name)775 static unsigned int round_name_to_mode(const char *name)
776 {
777 int i;
778
779 /* counting begins at 1 */
780 for (i = 1; i < NUM_ROUNDINGMODES; i++) {
781 if (!strcmp(round_mode_names[i], name)) {
782 return i;
783 }
784 }
785 return 0;
786 }
787
set_init_flags(const char * flags)788 static int set_init_flags(const char *flags)
789 {
790 const char *p;
791
792 for (p = flags; *p != '\0'; p++) {
793 switch (*p) {
794 case 'v':
795 slow_init_flags |= softfloat_flag_invalid;
796 qemu_init_flags |= float_flag_invalid;
797 break;
798 case 'i':
799 slow_init_flags |= softfloat_flag_infinite;
800 qemu_init_flags |= float_flag_divbyzero;
801 break;
802 case 'o':
803 slow_init_flags |= softfloat_flag_overflow;
804 qemu_init_flags |= float_flag_overflow;
805 break;
806 case 'u':
807 slow_init_flags |= softfloat_flag_underflow;
808 qemu_init_flags |= float_flag_underflow;
809 break;
810 case 'x':
811 slow_init_flags |= softfloat_flag_inexact;
812 qemu_init_flags |= float_flag_inexact;
813 break;
814 default:
815 return 1;
816 }
817 }
818 return 0;
819 }
820
slow_clear_flags(void)821 static uint_fast8_t slow_clear_flags(void)
822 {
823 uint8_t prev = slowfloat_exceptionFlags;
824
825 slowfloat_exceptionFlags = slow_init_flags;
826 return prev;
827 }
828
qemu_clear_flags(void)829 static uint_fast8_t qemu_clear_flags(void)
830 {
831 uint8_t prev = qemu_flags_to_sf(qsf.float_exception_flags);
832
833 qsf.float_exception_flags = qemu_init_flags;
834 return prev;
835 }
836
parse_args(int argc,char * argv[])837 static void parse_args(int argc, char *argv[])
838 {
839 unsigned int i;
840 int c;
841
842 for (;;) {
843 c = getopt(argc, argv, "he:f:l:r:sq");
844 if (c < 0) {
845 break;
846 }
847 switch (c) {
848 case 'h':
849 usage_complete(argc, argv);
850 exit(EXIT_SUCCESS);
851 case 'e':
852 if (qemu_strtoui(optarg, NULL, 0, &n_max_errors)) {
853 fprintf(stderr, "fatal: invalid max error count\n");
854 exit(EXIT_FAILURE);
855 }
856 break;
857 case 'f':
858 if (set_init_flags(optarg)) {
859 fprintf(stderr, "fatal: flags must be a subset of 'vioux'\n");
860 exit(EXIT_FAILURE);
861 }
862 break;
863 case 'l':
864 if (qemu_strtoi(optarg, NULL, 0, &test_level)) {
865 fprintf(stderr, "fatal: invalid test level\n");
866 exit(EXIT_FAILURE);
867 }
868 break;
869 case 'r':
870 if (!strcmp(optarg, "all")) {
871 test_round_mode = 0;
872 } else {
873 test_round_mode = round_name_to_mode(optarg);
874 if (test_round_mode == 0) {
875 fprintf(stderr, "fatal: invalid rounding mode\n");
876 exit(EXIT_FAILURE);
877 }
878 }
879 break;
880 /*
881 * The following flags are declared in testfloat/source/verCases_common.c
882 */
883 case 's':
884 verCases_errorStop = true;
885 break;
886 case 'q':
887 verCases_verbosity = 0;
888 break;
889 case '?':
890 /* invalid option or missing argument; getopt prints error info */
891 exit(EXIT_FAILURE);
892 }
893 }
894
895 /* set rounding modes */
896 if (test_round_mode == 0) {
897 /* test all rounding modes; note that counting begins at 1 */
898 n_round_modes = NUM_ROUNDINGMODES - 1;
899 round_modes = g_malloc_n(n_round_modes, sizeof(*round_modes));
900 for (i = 0; i < n_round_modes; i++) {
901 round_modes[i] = i + 1;
902 }
903 } else {
904 n_round_modes = 1;
905 round_modes = g_malloc(sizeof(*round_modes));
906 round_modes[0] = test_round_mode;
907 }
908
909 /* set test ops */
910 if (optind == argc) {
911 /* test all ops; note that counting begins at 1 */
912 n_test_ops = NUM_FUNCTIONS - 1;
913 test_ops = g_malloc_n(n_test_ops, sizeof(*test_ops));
914 for (i = 0; i < n_test_ops; i++) {
915 test_ops[i] = i + 1;
916 }
917 } else {
918 n_test_ops = argc - optind;
919 test_ops = g_malloc_n(n_test_ops, sizeof(*test_ops));
920 for (i = 0; i < n_test_ops; i++) {
921 const char *name = argv[i + optind];
922 unsigned int op = test_name_to_op(name);
923
924 if (op == 0) {
925 fprintf(stderr, "fatal: invalid op '%s'\n", name);
926 exit(EXIT_FAILURE);
927 }
928 test_ops[i] = op;
929 }
930 }
931 }
932
933 static G_NORETURN
run_test(void)934 void run_test(void)
935 {
936 unsigned int i;
937
938 genCases_setLevel(test_level);
939 verCases_maxErrorCount = n_max_errors;
940
941 testLoops_trueFlagsFunction = slow_clear_flags;
942 testLoops_subjFlagsFunction = qemu_clear_flags;
943
944 for (i = 0; i < n_test_ops; i++) {
945 unsigned int op = test_ops[i];
946 int j;
947
948 if (functionInfos[op].namePtr == NULL) {
949 continue;
950 }
951 verCases_functionNamePtr = functionInfos[op].namePtr;
952
953 for (j = 0; j < n_round_modes; j++) {
954 int attrs = functionInfos[op].attribs;
955 int round = round_modes[j];
956 int rmode = roundingModes[round];
957 int k;
958
959 verCases_roundingCode = 0;
960 slowfloat_roundingMode = rmode;
961 qsf.float_rounding_mode = sf_rounding_to_qemu(rmode);
962
963 if (attrs & (FUNC_ARG_ROUNDINGMODE | FUNC_EFF_ROUNDINGMODE)) {
964 /* print rounding mode if the op is affected by it */
965 verCases_roundingCode = round;
966 } else if (j > 0) {
967 /* if the op is not sensitive to rounding, move on */
968 break;
969 }
970
971 /* QEMU doesn't have !exact */
972 verCases_exact = true;
973 verCases_usesExact = !!(attrs & FUNC_ARG_EXACT);
974
975 for (k = 0; k < 3; k++) {
976 FloatX80RoundPrec qsf_prec80 = floatx80_precision_x;
977 int prec80 = 80;
978 int l;
979
980 if (k == 1) {
981 prec80 = 64;
982 qsf_prec80 = floatx80_precision_d;
983 } else if (k == 2) {
984 prec80 = 32;
985 qsf_prec80 = floatx80_precision_s;
986 }
987
988 verCases_roundingPrecision = 0;
989 slow_extF80_roundingPrecision = prec80;
990 qsf.floatx80_rounding_precision = qsf_prec80;
991
992 if (attrs & FUNC_EFF_ROUNDINGPRECISION) {
993 verCases_roundingPrecision = prec80;
994 } else if (k > 0) {
995 /* if the op is not sensitive to prec80, move on */
996 break;
997 }
998
999 /* note: the count begins at 1 */
1000 for (l = 1; l < NUM_TININESSMODES; l++) {
1001 int tmode = tininessModes[l];
1002
1003 verCases_tininessCode = 0;
1004 slowfloat_detectTininess = tmode;
1005 qsf.tininess_before_rounding = sf_tininess_to_qemu(tmode);
1006
1007 if (attrs & FUNC_EFF_TININESSMODE ||
1008 ((attrs & FUNC_EFF_TININESSMODE_REDUCEDPREC) &&
1009 prec80 && prec80 < 80)) {
1010 verCases_tininessCode = l;
1011 } else if (l > 1) {
1012 /* if the op is not sensitive to tininess, move on */
1013 break;
1014 }
1015
1016 do_testfloat(op, rmode, true);
1017 }
1018 }
1019 }
1020 }
1021 verCases_exitWithStatus();
1022 /* old compilers might miss that we exited */
1023 g_assert_not_reached();
1024 }
1025
main(int argc,char * argv[])1026 int main(int argc, char *argv[])
1027 {
1028 parse_args(argc, argv);
1029 fail_programName = argv[0];
1030 run_test(); /* does not return */
1031 }
1032