tests/fp/fp-test.c

   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";
 110
 111 static void usage_complete(int argc, char *argv[])
 112 {
 113     fprintf(stderr, "Usage: %s [options] [operation1 ...]\n", argv[0]);
 114     fprintf(stderr, "%s\n", commands_string);
 115     exit(EXIT_FAILURE);
 116 }
 117
 118 /* keep wrappers separate but do not bother defining headers for all of them */
 119 #include "wrap.inc.c"
 120
 121 static void not_implemented(void)
 122 {
 123     fprintf(stderr, "Not implemented.\n");
 124 }
 125
 126 static bool blacklisted(unsigned op, int rmode)
 127 {
 128     /* odd has only been implemented for a few 128-bit ops */
 129     if (rmode == softfloat_round_odd) {
 130         switch (op) {
 131         case F128_ADD:
 132         case F128_SUB:
 133         case F128_MUL:
 134         case F128_DIV:
 135         case F128_TO_F64:
 136         case F128_SQRT:
 137             return false;
 138         default:
 139             return true;
 140         }
 141     }
 142     return false;
 143 }
 144
 145 static void do_testfloat(int op, int rmode, bool exact)
 146 {
 147     abz_f16 true_abz_f16;
 148     abz_f16 subj_abz_f16;
 149     ab_f16_z_bool true_f16_z_bool;
 150     ab_f16_z_bool subj_f16_z_bool;
 151     abz_f32 true_abz_f32;
 152     abz_f32 subj_abz_f32;
 153     ab_f32_z_bool true_ab_f32_z_bool;
 154     ab_f32_z_bool subj_ab_f32_z_bool;
 155     abz_f64 true_abz_f64;
 156     abz_f64 subj_abz_f64;
 157     ab_f64_z_bool true_ab_f64_z_bool;
 158     ab_f64_z_bool subj_ab_f64_z_bool;
 159     abz_extF80M true_abz_extF80M;
 160     abz_extF80M subj_abz_extF80M;
 161     ab_extF80M_z_bool true_ab_extF80M_z_bool;
 162     ab_extF80M_z_bool subj_ab_extF80M_z_bool;
 163     abz_f128M true_abz_f128M;
 164     abz_f128M subj_abz_f128M;
 165     ab_f128M_z_bool true_ab_f128M_z_bool;
 166     ab_f128M_z_bool subj_ab_f128M_z_bool;
 167
 168     fputs(">> Testing ", stderr);
 169     verCases_writeFunctionName(stderr);
 170     fputs("\n", stderr);
 171
 172     if (blacklisted(op, rmode)) {
 173         not_implemented();
 174         return;
 175     }
 176
 177     switch (op) {
 178     case UI32_TO_F16:
 179         test_a_ui32_z_f16(slow_ui32_to_f16, qemu_ui32_to_f16);
 180         break;
 181     case UI32_TO_F32:
 182         test_a_ui32_z_f32(slow_ui32_to_f32, qemu_ui32_to_f32);
 183         break;
 184     case UI32_TO_F64:
 185         test_a_ui32_z_f64(slow_ui32_to_f64, qemu_ui32_to_f64);
 186         break;
 187     case UI32_TO_EXTF80:
 188         not_implemented();
 189         break;
 190     case UI32_TO_F128:
 191         not_implemented();
 192         break;
 193     case UI64_TO_F16:
 194         test_a_ui64_z_f16(slow_ui64_to_f16, qemu_ui64_to_f16);
 195         break;
 196     case UI64_TO_F32:
 197         test_a_ui64_z_f32(slow_ui64_to_f32, qemu_ui64_to_f32);
 198         break;
 199     case UI64_TO_F64:
 200         test_a_ui64_z_f64(slow_ui64_to_f64, qemu_ui64_to_f64);
 201         break;
 202     case UI64_TO_EXTF80:
 203         not_implemented();
 204         break;
 205     case UI64_TO_F128:
 206         test_a_ui64_z_f128(slow_ui64_to_f128M, qemu_ui64_to_f128M);
 207         break;
 208     case I32_TO_F16:
 209         test_a_i32_z_f16(slow_i32_to_f16, qemu_i32_to_f16);
 210         break;
 211     case I32_TO_F32:
 212         test_a_i32_z_f32(slow_i32_to_f32, qemu_i32_to_f32);
 213         break;
 214     case I32_TO_F64:
 215         test_a_i32_z_f64(slow_i32_to_f64, qemu_i32_to_f64);
 216         break;
 217     case I32_TO_EXTF80:
 218         test_a_i32_z_extF80(slow_i32_to_extF80M, qemu_i32_to_extF80M);
 219         break;
 220     case I32_TO_F128:
 221         test_a_i32_z_f128(slow_i32_to_f128M, qemu_i32_to_f128M);
 222         break;
 223     case I64_TO_F16:
 224         test_a_i64_z_f16(slow_i64_to_f16, qemu_i64_to_f16);
 225         break;
 226     case I64_TO_F32:
 227         test_a_i64_z_f32(slow_i64_to_f32, qemu_i64_to_f32);
 228         break;
 229     case I64_TO_F64:
 230         test_a_i64_z_f64(slow_i64_to_f64, qemu_i64_to_f64);
 231         break;
 232     case I64_TO_EXTF80:
 233         test_a_i64_z_extF80(slow_i64_to_extF80M, qemu_i64_to_extF80M);
 234         break;
 235     case I64_TO_F128:
 236         test_a_i64_z_f128(slow_i64_to_f128M, qemu_i64_to_f128M);
 237         break;
 238     case F16_TO_UI32:
 239         test_a_f16_z_ui32_rx(slow_f16_to_ui32, qemu_f16_to_ui32, rmode, exact);
 240         break;
 241     case F16_TO_UI64:
 242         test_a_f16_z_ui64_rx(slow_f16_to_ui64, qemu_f16_to_ui64, rmode, exact);
 243         break;
 244     case F16_TO_I32:
 245         test_a_f16_z_i32_rx(slow_f16_to_i32, qemu_f16_to_i32, rmode, exact);
 246         break;
 247     case F16_TO_I64:
 248         test_a_f16_z_i64_rx(slow_f16_to_i64, qemu_f16_to_i64, rmode, exact);
 249         break;
 250     case F16_TO_UI32_R_MINMAG:
 251         test_a_f16_z_ui32_x(slow_f16_to_ui32_r_minMag,
 252                             qemu_f16_to_ui32_r_minMag, exact);
 253         break;
 254     case F16_TO_UI64_R_MINMAG:
 255         test_a_f16_z_ui64_x(slow_f16_to_ui64_r_minMag,
 256                             qemu_f16_to_ui64_r_minMag, exact);
 257         break;
 258     case F16_TO_I32_R_MINMAG:
 259         test_a_f16_z_i32_x(slow_f16_to_i32_r_minMag, qemu_f16_to_i32_r_minMag,
 260                            exact);
 261         break;
 262     case F16_TO_I64_R_MINMAG:
 263         test_a_f16_z_i64_x(slow_f16_to_i64_r_minMag, qemu_f16_to_i64_r_minMag,
 264                            exact);
 265         break;
 266     case F16_TO_F32:
 267         test_a_f16_z_f32(slow_f16_to_f32, qemu_f16_to_f32);
 268         break;
 269     case F16_TO_F64:
 270         test_a_f16_z_f64(slow_f16_to_f64, qemu_f16_to_f64);
 271         break;
 272     case F16_TO_EXTF80:
 273         not_implemented();
 274         break;
 275     case F16_TO_F128:
 276         not_implemented();
 277         break;
 278     case F16_ROUNDTOINT:
 279         test_az_f16_rx(slow_f16_roundToInt, qemu_f16_roundToInt, rmode, exact);
 280         break;
 281     case F16_ADD:
 282         true_abz_f16 = slow_f16_add;
 283         subj_abz_f16 = qemu_f16_add;
 284         goto test_abz_f16;
 285     case F16_SUB:
 286         true_abz_f16 = slow_f16_sub;
 287         subj_abz_f16 = qemu_f16_sub;
 288         goto test_abz_f16;
 289     case F16_MUL:
 290         true_abz_f16 = slow_f16_mul;
 291         subj_abz_f16 = qemu_f16_mul;
 292         goto test_abz_f16;
 293     case F16_DIV:
 294         true_abz_f16 = slow_f16_div;
 295         subj_abz_f16 = qemu_f16_div;
 296         goto test_abz_f16;
 297     case F16_REM:
 298         not_implemented();
 299         break;
 300     test_abz_f16:
 301         test_abz_f16(true_abz_f16, subj_abz_f16);
 302         break;
 303     case F16_MULADD:
 304         test_abcz_f16(slow_f16_mulAdd, qemu_f16_mulAdd);
 305         break;
 306     case F16_SQRT:
 307         test_az_f16(slow_f16_sqrt, qemu_f16_sqrt);
 308         break;
 309     case F16_EQ:
 310         true_f16_z_bool = slow_f16_eq;
 311         subj_f16_z_bool = qemu_f16_eq;
 312         goto test_ab_f16_z_bool;
 313     case F16_LE:
 314         true_f16_z_bool = slow_f16_le;
 315         subj_f16_z_bool = qemu_f16_le;
 316         goto test_ab_f16_z_bool;
 317     case F16_LT:
 318         true_f16_z_bool = slow_f16_lt;
 319         subj_f16_z_bool = qemu_f16_lt;
 320         goto test_ab_f16_z_bool;
 321     case F16_EQ_SIGNALING:
 322         true_f16_z_bool = slow_f16_eq_signaling;
 323         subj_f16_z_bool = qemu_f16_eq_signaling;
 324         goto test_ab_f16_z_bool;
 325     case F16_LE_QUIET:
 326         true_f16_z_bool = slow_f16_le_quiet;
 327         subj_f16_z_bool = qemu_f16_le_quiet;
 328         goto test_ab_f16_z_bool;
 329     case F16_LT_QUIET:
 330         true_f16_z_bool = slow_f16_lt_quiet;
 331         subj_f16_z_bool = qemu_f16_lt_quiet;
 332     test_ab_f16_z_bool:
 333         test_ab_f16_z_bool(true_f16_z_bool, subj_f16_z_bool);
 334         break;
 335     case F32_TO_UI32:
 336         test_a_f32_z_ui32_rx(slow_f32_to_ui32, qemu_f32_to_ui32, rmode, exact);
 337         break;
 338     case F32_TO_UI64:
 339         test_a_f32_z_ui64_rx(slow_f32_to_ui64, qemu_f32_to_ui64, rmode, exact);
 340         break;
 341     case F32_TO_I32:
 342         test_a_f32_z_i32_rx(slow_f32_to_i32, qemu_f32_to_i32, rmode, exact);
 343         break;
 344     case F32_TO_I64:
 345         test_a_f32_z_i64_rx(slow_f32_to_i64, qemu_f32_to_i64, rmode, exact);
 346         break;
 347     case F32_TO_UI32_R_MINMAG:
 348         test_a_f32_z_ui32_x(slow_f32_to_ui32_r_minMag,
 349                             qemu_f32_to_ui32_r_minMag, exact);
 350         break;
 351     case F32_TO_UI64_R_MINMAG:
 352         test_a_f32_z_ui64_x(slow_f32_to_ui64_r_minMag,
 353                             qemu_f32_to_ui64_r_minMag, exact);
 354         break;
 355     case F32_TO_I32_R_MINMAG:
 356         test_a_f32_z_i32_x(slow_f32_to_i32_r_minMag, qemu_f32_to_i32_r_minMag,
 357                            exact);
 358         break;
 359     case F32_TO_I64_R_MINMAG:
 360         test_a_f32_z_i64_x(slow_f32_to_i64_r_minMag, qemu_f32_to_i64_r_minMag,
 361                            exact);
 362         break;
 363     case F32_TO_F16:
 364         test_a_f32_z_f16(slow_f32_to_f16, qemu_f32_to_f16);
 365         break;
 366     case F32_TO_F64:
 367         test_a_f32_z_f64(slow_f32_to_f64, qemu_f32_to_f64);
 368         break;
 369     case F32_TO_EXTF80:
 370         test_a_f32_z_extF80(slow_f32_to_extF80M, qemu_f32_to_extF80M);
 371         break;
 372     case F32_TO_F128:
 373         test_a_f32_z_f128(slow_f32_to_f128M, qemu_f32_to_f128M);
 374         break;
 375     case F32_ROUNDTOINT:
 376         test_az_f32_rx(slow_f32_roundToInt, qemu_f32_roundToInt, rmode, exact);
 377         break;
 378     case F32_ADD:
 379         true_abz_f32 = slow_f32_add;
 380         subj_abz_f32 = qemu_f32_add;
 381         goto test_abz_f32;
 382     case F32_SUB:
 383         true_abz_f32 = slow_f32_sub;
 384         subj_abz_f32 = qemu_f32_sub;
 385         goto test_abz_f32;
 386     case F32_MUL:
 387         true_abz_f32 = slow_f32_mul;
 388         subj_abz_f32 = qemu_f32_mul;
 389         goto test_abz_f32;
 390     case F32_DIV:
 391         true_abz_f32 = slow_f32_div;
 392         subj_abz_f32 = qemu_f32_div;
 393         goto test_abz_f32;
 394     case F32_REM:
 395         true_abz_f32 = slow_f32_rem;
 396         subj_abz_f32 = qemu_f32_rem;
 397     test_abz_f32:
 398         test_abz_f32(true_abz_f32, subj_abz_f32);
 399         break;
 400     case F32_MULADD:
 401         test_abcz_f32(slow_f32_mulAdd, qemu_f32_mulAdd);
 402         break;
 403     case F32_SQRT:
 404         test_az_f32(slow_f32_sqrt, qemu_f32_sqrt);
 405         break;
 406     case F32_EQ:
 407         true_ab_f32_z_bool = slow_f32_eq;
 408         subj_ab_f32_z_bool = qemu_f32_eq;
 409         goto test_ab_f32_z_bool;
 410     case F32_LE:
 411         true_ab_f32_z_bool = slow_f32_le;
 412         subj_ab_f32_z_bool = qemu_f32_le;
 413         goto test_ab_f32_z_bool;
 414     case F32_LT:
 415         true_ab_f32_z_bool = slow_f32_lt;
 416         subj_ab_f32_z_bool = qemu_f32_lt;
 417         goto test_ab_f32_z_bool;
 418     case F32_EQ_SIGNALING:
 419         true_ab_f32_z_bool = slow_f32_eq_signaling;
 420         subj_ab_f32_z_bool = qemu_f32_eq_signaling;
 421         goto test_ab_f32_z_bool;
 422     case F32_LE_QUIET:
 423         true_ab_f32_z_bool = slow_f32_le_quiet;
 424         subj_ab_f32_z_bool = qemu_f32_le_quiet;
 425         goto test_ab_f32_z_bool;
 426     case F32_LT_QUIET:
 427         true_ab_f32_z_bool = slow_f32_lt_quiet;
 428         subj_ab_f32_z_bool = qemu_f32_lt_quiet;
 429     test_ab_f32_z_bool:
 430         test_ab_f32_z_bool(true_ab_f32_z_bool, subj_ab_f32_z_bool);
 431         break;
 432     case F64_TO_UI32:
 433         test_a_f64_z_ui32_rx(slow_f64_to_ui32, qemu_f64_to_ui32, rmode, exact);
 434         break;
 435     case F64_TO_UI64:
 436         test_a_f64_z_ui64_rx(slow_f64_to_ui64, qemu_f64_to_ui64, rmode, exact);
 437         break;
 438     case F64_TO_I32:
 439         test_a_f64_z_i32_rx(slow_f64_to_i32, qemu_f64_to_i32, rmode, exact);
 440         break;
 441     case F64_TO_I64:
 442         test_a_f64_z_i64_rx(slow_f64_to_i64, qemu_f64_to_i64, rmode, exact);
 443         break;
 444     case F64_TO_UI32_R_MINMAG:
 445         test_a_f64_z_ui32_x(slow_f64_to_ui32_r_minMag,
 446                             qemu_f64_to_ui32_r_minMag, exact);
 447         break;
 448     case F64_TO_UI64_R_MINMAG:
 449         test_a_f64_z_ui64_x(slow_f64_to_ui64_r_minMag,
 450                             qemu_f64_to_ui64_r_minMag, exact);
 451         break;
 452     case F64_TO_I32_R_MINMAG:
 453         test_a_f64_z_i32_x(slow_f64_to_i32_r_minMag, qemu_f64_to_i32_r_minMag,
 454                            exact);
 455         break;
 456     case F64_TO_I64_R_MINMAG:
 457         test_a_f64_z_i64_x(slow_f64_to_i64_r_minMag, qemu_f64_to_i64_r_minMag,
 458                            exact);
 459         break;
 460     case F64_TO_F16:
 461         test_a_f64_z_f16(slow_f64_to_f16, qemu_f64_to_f16);
 462         break;
 463     case F64_TO_F32:
 464         test_a_f64_z_f32(slow_f64_to_f32, qemu_f64_to_f32);
 465         break;
 466     case F64_TO_EXTF80:
 467         test_a_f64_z_extF80(slow_f64_to_extF80M, qemu_f64_to_extF80M);
 468         break;
 469     case F64_TO_F128:
 470         test_a_f64_z_f128(slow_f64_to_f128M, qemu_f64_to_f128M);
 471         break;
 472     case F64_ROUNDTOINT:
 473         test_az_f64_rx(slow_f64_roundToInt, qemu_f64_roundToInt, rmode, exact);
 474         break;
 475     case F64_ADD:
 476         true_abz_f64 = slow_f64_add;
 477         subj_abz_f64 = qemu_f64_add;
 478         goto test_abz_f64;
 479     case F64_SUB:
 480         true_abz_f64 = slow_f64_sub;
 481         subj_abz_f64 = qemu_f64_sub;
 482         goto test_abz_f64;
 483     case F64_MUL:
 484         true_abz_f64 = slow_f64_mul;
 485         subj_abz_f64 = qemu_f64_mul;
 486         goto test_abz_f64;
 487     case F64_DIV:
 488         true_abz_f64 = slow_f64_div;
 489         subj_abz_f64 = qemu_f64_div;
 490         goto test_abz_f64;
 491     case F64_REM:
 492         true_abz_f64 = slow_f64_rem;
 493         subj_abz_f64 = qemu_f64_rem;
 494     test_abz_f64:
 495         test_abz_f64(true_abz_f64, subj_abz_f64);
 496         break;
 497     case F64_MULADD:
 498         test_abcz_f64(slow_f64_mulAdd, qemu_f64_mulAdd);
 499         break;
 500     case F64_SQRT:
 501         test_az_f64(slow_f64_sqrt, qemu_f64_sqrt);
 502         break;
 503     case F64_EQ:
 504         true_ab_f64_z_bool = slow_f64_eq;
 505         subj_ab_f64_z_bool = qemu_f64_eq;
 506         goto test_ab_f64_z_bool;
 507     case F64_LE:
 508         true_ab_f64_z_bool = slow_f64_le;
 509         subj_ab_f64_z_bool = qemu_f64_le;
 510         goto test_ab_f64_z_bool;
 511     case F64_LT:
 512         true_ab_f64_z_bool = slow_f64_lt;
 513         subj_ab_f64_z_bool = qemu_f64_lt;
 514         goto test_ab_f64_z_bool;
 515     case F64_EQ_SIGNALING:
 516         true_ab_f64_z_bool = slow_f64_eq_signaling;
 517         subj_ab_f64_z_bool = qemu_f64_eq_signaling;
 518         goto test_ab_f64_z_bool;
 519     case F64_LE_QUIET:
 520         true_ab_f64_z_bool = slow_f64_le_quiet;
 521         subj_ab_f64_z_bool = qemu_f64_le_quiet;
 522         goto test_ab_f64_z_bool;
 523     case F64_LT_QUIET:
 524         true_ab_f64_z_bool = slow_f64_lt_quiet;
 525         subj_ab_f64_z_bool = qemu_f64_lt_quiet;
 526     test_ab_f64_z_bool:
 527         test_ab_f64_z_bool(true_ab_f64_z_bool, subj_ab_f64_z_bool);
 528         break;
 529     case EXTF80_TO_UI32:
 530         not_implemented();
 531         break;
 532     case EXTF80_TO_UI64:
 533         not_implemented();
 534         break;
 535     case EXTF80_TO_I32:
 536         test_a_extF80_z_i32_rx(slow_extF80M_to_i32, qemu_extF80M_to_i32, rmode,
 537                                exact);
 538         break;
 539     case EXTF80_TO_I64:
 540         test_a_extF80_z_i64_rx(slow_extF80M_to_i64, qemu_extF80M_to_i64, rmode,
 541                                exact);
 542         break;
 543     case EXTF80_TO_UI32_R_MINMAG:
 544         not_implemented();
 545         break;
 546     case EXTF80_TO_UI64_R_MINMAG:
 547         not_implemented();
 548         break;
 549     case EXTF80_TO_I32_R_MINMAG:
 550         test_a_extF80_z_i32_x(slow_extF80M_to_i32_r_minMag,
 551                               qemu_extF80M_to_i32_r_minMag, exact);
 552         break;
 553     case EXTF80_TO_I64_R_MINMAG:
 554         test_a_extF80_z_i64_x(slow_extF80M_to_i64_r_minMag,
 555                               qemu_extF80M_to_i64_r_minMag, exact);
 556         break;
 557     case EXTF80_TO_F16:
 558         not_implemented();
 559         break;
 560     case EXTF80_TO_F32:
 561         test_a_extF80_z_f32(slow_extF80M_to_f32, qemu_extF80M_to_f32);
 562         break;
 563     case EXTF80_TO_F64:
 564         test_a_extF80_z_f64(slow_extF80M_to_f64, qemu_extF80M_to_f64);
 565         break;
 566     case EXTF80_TO_F128:
 567         test_a_extF80_z_f128(slow_extF80M_to_f128M, qemu_extF80M_to_f128M);
 568         break;
 569     case EXTF80_ROUNDTOINT:
 570         test_az_extF80_rx(slow_extF80M_roundToInt, qemu_extF80M_roundToInt,
 571                           rmode, exact);
 572         break;
 573     case EXTF80_ADD:
 574         true_abz_extF80M = slow_extF80M_add;
 575         subj_abz_extF80M = qemu_extF80M_add;
 576         goto test_abz_extF80;
 577     case EXTF80_SUB:
 578         true_abz_extF80M = slow_extF80M_sub;
 579         subj_abz_extF80M = qemu_extF80M_sub;
 580         goto test_abz_extF80;
 581     case EXTF80_MUL:
 582         true_abz_extF80M = slow_extF80M_mul;
 583         subj_abz_extF80M = qemu_extF80M_mul;
 584         goto test_abz_extF80;
 585     case EXTF80_DIV:
 586         true_abz_extF80M = slow_extF80M_div;
 587         subj_abz_extF80M = qemu_extF80M_div;
 588         goto test_abz_extF80;
 589     case EXTF80_REM:
 590         true_abz_extF80M = slow_extF80M_rem;
 591         subj_abz_extF80M = qemu_extF80M_rem;
 592     test_abz_extF80:
 593         test_abz_extF80(true_abz_extF80M, subj_abz_extF80M);
 594         break;
 595     case EXTF80_SQRT:
 596         test_az_extF80(slow_extF80M_sqrt, qemu_extF80M_sqrt);
 597         break;
 598     case EXTF80_EQ:
 599         true_ab_extF80M_z_bool = slow_extF80M_eq;
 600         subj_ab_extF80M_z_bool = qemu_extF80M_eq;
 601         goto test_ab_extF80_z_bool;
 602     case EXTF80_LE:
 603         true_ab_extF80M_z_bool = slow_extF80M_le;
 604         subj_ab_extF80M_z_bool = qemu_extF80M_le;
 605         goto test_ab_extF80_z_bool;
 606     case EXTF80_LT:
 607         true_ab_extF80M_z_bool = slow_extF80M_lt;
 608         subj_ab_extF80M_z_bool = qemu_extF80M_lt;
 609         goto test_ab_extF80_z_bool;
 610     case EXTF80_EQ_SIGNALING:
 611         true_ab_extF80M_z_bool = slow_extF80M_eq_signaling;
 612         subj_ab_extF80M_z_bool = qemu_extF80M_eq_signaling;
 613         goto test_ab_extF80_z_bool;
 614     case EXTF80_LE_QUIET:
 615         true_ab_extF80M_z_bool = slow_extF80M_le_quiet;
 616         subj_ab_extF80M_z_bool = qemu_extF80M_le_quiet;
 617         goto test_ab_extF80_z_bool;
 618     case EXTF80_LT_QUIET:
 619         true_ab_extF80M_z_bool = slow_extF80M_lt_quiet;
 620         subj_ab_extF80M_z_bool = qemu_extF80M_lt_quiet;
 621     test_ab_extF80_z_bool:
 622         test_ab_extF80_z_bool(true_ab_extF80M_z_bool, subj_ab_extF80M_z_bool);
 623         break;
 624     case F128_TO_UI32:
 625         not_implemented();
 626         break;
 627     case F128_TO_UI64:
 628         test_a_f128_z_ui64_rx(slow_f128M_to_ui64, qemu_f128M_to_ui64, rmode,
 629                               exact);
 630         break;
 631     case F128_TO_I32:
 632         test_a_f128_z_i32_rx(slow_f128M_to_i32, qemu_f128M_to_i32, rmode,
 633                              exact);
 634         break;
 635     case F128_TO_I64:
 636         test_a_f128_z_i64_rx(slow_f128M_to_i64, qemu_f128M_to_i64, rmode,
 637                              exact);
 638         break;
 639     case F128_TO_UI32_R_MINMAG:
 640         test_a_f128_z_ui32_x(slow_f128M_to_ui32_r_minMag,
 641                              qemu_f128M_to_ui32_r_minMag, exact);
 642         break;
 643     case F128_TO_UI64_R_MINMAG:
 644         test_a_f128_z_ui64_x(slow_f128M_to_ui64_r_minMag,
 645                              qemu_f128M_to_ui64_r_minMag, exact);
 646         break;
 647     case F128_TO_I32_R_MINMAG:
 648         test_a_f128_z_i32_x(slow_f128M_to_i32_r_minMag,
 649                             qemu_f128M_to_i32_r_minMag, exact);
 650         break;
 651     case F128_TO_I64_R_MINMAG:
 652         test_a_f128_z_i64_x(slow_f128M_to_i64_r_minMag,
 653                             qemu_f128M_to_i64_r_minMag, exact);
 654         break;
 655     case F128_TO_F16:
 656         not_implemented();
 657         break;
 658     case F128_TO_F32:
 659         test_a_f128_z_f32(slow_f128M_to_f32, qemu_f128M_to_f32);
 660         break;
 661     case F128_TO_F64:
 662         test_a_f128_z_f64(slow_f128M_to_f64, qemu_f128M_to_f64);
 663         break;
 664     case F128_TO_EXTF80:
 665         test_a_f128_z_extF80(slow_f128M_to_extF80M, qemu_f128M_to_extF80M);
 666         break;
 667     case F128_ROUNDTOINT:
 668         test_az_f128_rx(slow_f128M_roundToInt, qemu_f128M_roundToInt, rmode,
 669                         exact);
 670         break;
 671     case F128_ADD:
 672         true_abz_f128M = slow_f128M_add;
 673         subj_abz_f128M = qemu_f128M_add;
 674         goto test_abz_f128;
 675     case F128_SUB:
 676         true_abz_f128M = slow_f128M_sub;
 677         subj_abz_f128M = qemu_f128M_sub;
 678         goto test_abz_f128;
 679     case F128_MUL:
 680         true_abz_f128M = slow_f128M_mul;
 681         subj_abz_f128M = qemu_f128M_mul;
 682         goto test_abz_f128;
 683     case F128_DIV:
 684         true_abz_f128M = slow_f128M_div;
 685         subj_abz_f128M = qemu_f128M_div;
 686         goto test_abz_f128;
 687     case F128_REM:
 688         true_abz_f128M = slow_f128M_rem;
 689         subj_abz_f128M = qemu_f128M_rem;
 690     test_abz_f128:
 691         test_abz_f128(true_abz_f128M, subj_abz_f128M);
 692         break;
 693     case F128_MULADD:
 694         not_implemented();
 695         break;
 696     case F128_SQRT:
 697         test_az_f128(slow_f128M_sqrt, qemu_f128M_sqrt);
 698         break;
 699     case F128_EQ:
 700         true_ab_f128M_z_bool = slow_f128M_eq;
 701         subj_ab_f128M_z_bool = qemu_f128M_eq;
 702         goto test_ab_f128_z_bool;
 703     case F128_LE:
 704         true_ab_f128M_z_bool = slow_f128M_le;
 705         subj_ab_f128M_z_bool = qemu_f128M_le;
 706         goto test_ab_f128_z_bool;
 707     case F128_LT:
 708         true_ab_f128M_z_bool = slow_f128M_lt;
 709         subj_ab_f128M_z_bool = qemu_f128M_lt;
 710         goto test_ab_f128_z_bool;
 711     case F128_EQ_SIGNALING:
 712         true_ab_f128M_z_bool = slow_f128M_eq_signaling;
 713         subj_ab_f128M_z_bool = qemu_f128M_eq_signaling;
 714         goto test_ab_f128_z_bool;
 715     case F128_LE_QUIET:
 716         true_ab_f128M_z_bool = slow_f128M_le_quiet;
 717         subj_ab_f128M_z_bool = qemu_f128M_le_quiet;
 718         goto test_ab_f128_z_bool;
 719     case F128_LT_QUIET:
 720         true_ab_f128M_z_bool = slow_f128M_lt_quiet;
 721         subj_ab_f128M_z_bool = qemu_f128M_lt_quiet;
 722     test_ab_f128_z_bool:
 723         test_ab_f128_z_bool(true_ab_f128M_z_bool, subj_ab_f128M_z_bool);
 724         break;
 725     }
 726     if ((verCases_errorStop && verCases_anyErrors)) {
 727         verCases_exitWithStatus();
 728     }
 729 }
 730
 731 static unsigned int test_name_to_op(const char *arg)
 732 {
 733     unsigned int i;
 734
 735     /* counting begins at 1 */
 736     for (i = 1; i < NUM_FUNCTIONS; i++) {
 737         const char *name = functionInfos[i].namePtr;
 738
 739         if (name && !strcmp(name, arg)) {
 740             return i;
 741         }
 742     }
 743     return 0;
 744 }
 745
 746 static unsigned int round_name_to_mode(const char *name)
 747 {
 748     int i;
 749
 750     /* counting begins at 1 */
 751     for (i = 1; i < NUM_ROUNDINGMODES; i++) {
 752         if (!strcmp(round_mode_names[i], name)) {
 753             return i;
 754         }
 755     }
 756     return 0;
 757 }
 758
 759 static int set_init_flags(const char *flags)
 760 {
 761     const char *p;
 762
 763     for (p = flags; *p != '\0'; p++) {
 764         switch (*p) {
 765         case 'v':
 766             slow_init_flags |= softfloat_flag_invalid;
 767             qemu_init_flags |= float_flag_invalid;
 768             break;
 769         case 'i':
 770             slow_init_flags |= softfloat_flag_infinite;
 771             qemu_init_flags |= float_flag_divbyzero;
 772             break;
 773         case 'o':
 774             slow_init_flags |= softfloat_flag_overflow;
 775             qemu_init_flags |= float_flag_overflow;
 776             break;
 777         case 'u':
 778             slow_init_flags |= softfloat_flag_underflow;
 779             qemu_init_flags |= float_flag_underflow;
 780             break;
 781         case 'x':
 782             slow_init_flags |= softfloat_flag_inexact;
 783             qemu_init_flags |= float_flag_inexact;
 784             break;
 785         default:
 786             return 1;
 787         }
 788     }
 789     return 0;
 790 }
 791
 792 static uint8_t slow_clear_flags(void)
 793 {
 794     uint8_t prev = slowfloat_exceptionFlags;
 795
 796     slowfloat_exceptionFlags = slow_init_flags;
 797     return prev;
 798 }
 799
 800 static uint8_t qemu_clear_flags(void)
 801 {
 802     uint8_t prev = qemu_flags_to_sf(qsf.float_exception_flags);
 803
 804     qsf.float_exception_flags = qemu_init_flags;
 805     return prev;
 806 }
 807
 808 static void parse_args(int argc, char *argv[])
 809 {
 810     unsigned int i;
 811     int c;
 812
 813     for (;;) {
 814         c = getopt(argc, argv, "he:f:l:r:s");
 815         if (c < 0) {
 816             break;
 817         }
 818         switch (c) {
 819         case 'h':
 820             usage_complete(argc, argv);
 821             exit(EXIT_SUCCESS);
 822         case 'e':
 823             if (qemu_strtoui(optarg, NULL, 0, &n_max_errors)) {
 824                 fprintf(stderr, "fatal: invalid max error count\n");
 825                 exit(EXIT_FAILURE);
 826             }
 827             break;
 828         case 'f':
 829             if (set_init_flags(optarg)) {
 830                 fprintf(stderr, "fatal: flags must be a subset of 'vioux'\n");
 831                 exit(EXIT_FAILURE);
 832             }
 833             break;
 834         case 'l':
 835             if (qemu_strtoi(optarg, NULL, 0, &test_level)) {
 836                 fprintf(stderr, "fatal: invalid test level\n");
 837                 exit(EXIT_FAILURE);
 838             }
 839             break;
 840         case 'r':
 841             if (!strcmp(optarg, "all")) {
 842                 test_round_mode = 0;
 843             } else {
 844                 test_round_mode = round_name_to_mode(optarg);
 845                 if (test_round_mode == 0) {
 846                     fprintf(stderr, "fatal: invalid rounding mode\n");
 847                     exit(EXIT_FAILURE);
 848                 }
 849             }
 850             break;
 851         case 's':
 852             verCases_errorStop = true;
 853             break;
 854         case '?':
 855             /* invalid option or missing argument; getopt prints error info */
 856             exit(EXIT_FAILURE);
 857         }
 858     }
 859
 860     /* set rounding modes */
 861     if (test_round_mode == 0) {
 862         /* test all rounding modes; note that counting begins at 1 */
 863         n_round_modes = NUM_ROUNDINGMODES - 1;
 864         round_modes = g_malloc_n(n_round_modes, sizeof(*round_modes));
 865         for (i = 0; i < n_round_modes; i++) {
 866             round_modes[i] = i + 1;
 867         }
 868     } else {
 869         n_round_modes = 1;
 870         round_modes = g_malloc(sizeof(*round_modes));
 871         round_modes[0] = test_round_mode;
 872     }
 873
 874     /* set test ops */
 875     if (optind == argc) {
 876         /* test all ops; note that counting begins at 1 */
 877         n_test_ops = NUM_FUNCTIONS - 1;
 878         test_ops = g_malloc_n(n_test_ops, sizeof(*test_ops));
 879         for (i = 0; i < n_test_ops; i++) {
 880             test_ops[i] = i + 1;
 881         }
 882     } else {
 883         n_test_ops = argc - optind;
 884         test_ops = g_malloc_n(n_test_ops, sizeof(*test_ops));
 885         for (i = 0; i < n_test_ops; i++) {
 886             const char *name = argv[i + optind];
 887             unsigned int op = test_name_to_op(name);
 888
 889             if (op == 0) {
 890                 fprintf(stderr, "fatal: invalid op '%s'\n", name);
 891                 exit(EXIT_FAILURE);
 892             }
 893             test_ops[i] = op;
 894         }
 895     }
 896 }
 897
 898 static void QEMU_NORETURN run_test(void)
 899 {
 900     unsigned int i;
 901
 902     genCases_setLevel(test_level);
 903     verCases_maxErrorCount = n_max_errors;
 904
 905     testLoops_trueFlagsFunction = slow_clear_flags;
 906     testLoops_subjFlagsFunction = qemu_clear_flags;
 907
 908     for (i = 0; i < n_test_ops; i++) {
 909         unsigned int op = test_ops[i];
 910         int j;
 911
 912         if (functionInfos[op].namePtr == NULL) {
 913             continue;
 914         }
 915         verCases_functionNamePtr = functionInfos[op].namePtr;
 916
 917         for (j = 0; j < n_round_modes; j++) {
 918             int attrs = functionInfos[op].attribs;
 919             int round = round_modes[j];
 920             int rmode = roundingModes[round];
 921             int k;
 922
 923             verCases_roundingCode = 0;
 924             slowfloat_roundingMode = rmode;
 925             qsf.float_rounding_mode = sf_rounding_to_qemu(rmode);
 926
 927             if (attrs & (FUNC_ARG_ROUNDINGMODE | FUNC_EFF_ROUNDINGMODE)) {
 928                 /* print rounding mode if the op is affected by it */
 929                 verCases_roundingCode = round;
 930             } else if (j > 0) {
 931                 /* if the op is not sensitive to rounding, move on */
 932                 break;
 933             }
 934
 935             /* QEMU doesn't have !exact */
 936             verCases_exact = true;
 937             verCases_usesExact = !!(attrs & FUNC_ARG_EXACT);
 938
 939             for (k = 0; k < 3; k++) {
 940                 int prec80 = 32;
 941                 int l;
 942
 943                 if (k == 1) {
 944                     prec80 = 64;
 945                 } else if (k == 2) {
 946                     prec80 = 80;
 947                 }
 948
 949                 verCases_roundingPrecision = 0;
 950                 slow_extF80_roundingPrecision = prec80;
 951                 qsf.floatx80_rounding_precision = prec80;
 952
 953                 if (attrs & FUNC_EFF_ROUNDINGPRECISION) {
 954                     verCases_roundingPrecision = prec80;
 955                 } else if (k > 0) {
 956                     /* if the op is not sensitive to prec80, move on */
 957                     break;
 958                 }
 959
 960                 /* note: the count begins at 1 */
 961                 for (l = 1; l < NUM_TININESSMODES; l++) {
 962                     int tmode = tininessModes[l];
 963
 964                     verCases_tininessCode = 0;
 965                     slowfloat_detectTininess = tmode;
 966                     qsf.float_detect_tininess = sf_tininess_to_qemu(tmode);
 967
 968                     if (attrs & FUNC_EFF_TININESSMODE ||
 969                         ((attrs & FUNC_EFF_TININESSMODE_REDUCEDPREC) &&
 970                          prec80 && prec80 < 80)) {
 971                         verCases_tininessCode = l;
 972                     } else if (l > 1) {
 973                         /* if the op is not sensitive to tininess, move on */
 974                         break;
 975                     }
 976
 977                     do_testfloat(op, rmode, true);
 978                 }
 979             }
 980         }
 981     }
 982     verCases_exitWithStatus();
 983     /* old compilers might miss that we exited */
 984     g_assert_not_reached();
 985 }
 986
 987 int main(int argc, char *argv[])
 988 {
 989     parse_args(argc, argv);
 990     fail_programName = argv[0];
 991     run_test(); /* does not return */
 992 }