--- /dev/null
+sqrt 0
+= sqrt downward flt-32 0x0p+0f : 0x0p+0f :
+= sqrt tonearest flt-32 0x0p+0f : 0x0p+0f :
+= sqrt towardzero flt-32 0x0p+0f : 0x0p+0f :
+= sqrt upward flt-32 0x0p+0f : 0x0p+0f :
+= sqrt downward dbl-64 0x0p+0 : 0x0p+0 :
+= sqrt tonearest dbl-64 0x0p+0 : 0x0p+0 :
+= sqrt towardzero dbl-64 0x0p+0 : 0x0p+0 :
+= sqrt upward dbl-64 0x0p+0 : 0x0p+0 :
+= sqrt downward ldbl-96-intel 0x0p+0L : 0x0p+0L :
+= sqrt tonearest ldbl-96-intel 0x0p+0L : 0x0p+0L :
+= sqrt towardzero ldbl-96-intel 0x0p+0L : 0x0p+0L :
+= sqrt upward ldbl-96-intel 0x0p+0L : 0x0p+0L :
+= sqrt downward ldbl-96-m68k 0x0p+0L : 0x0p+0L :
+= sqrt tonearest ldbl-96-m68k 0x0p+0L : 0x0p+0L :
+= sqrt towardzero ldbl-96-m68k 0x0p+0L : 0x0p+0L :
+= sqrt upward ldbl-96-m68k 0x0p+0L : 0x0p+0L :
+= sqrt downward ldbl-128 0x0p+0L : 0x0p+0L :
+= sqrt tonearest ldbl-128 0x0p+0L : 0x0p+0L :
+= sqrt towardzero ldbl-128 0x0p+0L : 0x0p+0L :
+= sqrt upward ldbl-128 0x0p+0L : 0x0p+0L :
+= sqrt downward ldbl-128ibm 0x0p+0L : 0x0p+0L :
+= sqrt tonearest ldbl-128ibm 0x0p+0L : 0x0p+0L :
+= sqrt towardzero ldbl-128ibm 0x0p+0L : 0x0p+0L :
+= sqrt upward ldbl-128ibm 0x0p+0L : 0x0p+0L :
+sqrt -0
+= sqrt downward flt-32 -0x0p+0f : -0x0p+0f :
+= sqrt tonearest flt-32 -0x0p+0f : -0x0p+0f :
+= sqrt towardzero flt-32 -0x0p+0f : -0x0p+0f :
+= sqrt upward flt-32 -0x0p+0f : -0x0p+0f :
+= sqrt downward dbl-64 -0x0p+0 : -0x0p+0 :
+= sqrt tonearest dbl-64 -0x0p+0 : -0x0p+0 :
+= sqrt towardzero dbl-64 -0x0p+0 : -0x0p+0 :
+= sqrt upward dbl-64 -0x0p+0 : -0x0p+0 :
+= sqrt downward ldbl-96-intel -0x0p+0L : -0x0p+0L :
+= sqrt tonearest ldbl-96-intel -0x0p+0L : -0x0p+0L :
+= sqrt towardzero ldbl-96-intel -0x0p+0L : -0x0p+0L :
+= sqrt upward ldbl-96-intel -0x0p+0L : -0x0p+0L :
+= sqrt downward ldbl-96-m68k -0x0p+0L : -0x0p+0L :
+= sqrt tonearest ldbl-96-m68k -0x0p+0L : -0x0p+0L :
+= sqrt towardzero ldbl-96-m68k -0x0p+0L : -0x0p+0L :
+= sqrt upward ldbl-96-m68k -0x0p+0L : -0x0p+0L :
+= sqrt downward ldbl-128 -0x0p+0L : -0x0p+0L :
+= sqrt tonearest ldbl-128 -0x0p+0L : -0x0p+0L :
+= sqrt towardzero ldbl-128 -0x0p+0L : -0x0p+0L :
+= sqrt upward ldbl-128 -0x0p+0L : -0x0p+0L :
+= sqrt downward ldbl-128ibm -0x0p+0L : -0x0p+0L :
+= sqrt tonearest ldbl-128ibm -0x0p+0L : -0x0p+0L :
+= sqrt towardzero ldbl-128ibm -0x0p+0L : -0x0p+0L :
+= sqrt upward ldbl-128ibm -0x0p+0L : -0x0p+0L :
+sqrt 2209
+= sqrt downward flt-32 0x8.a1p+8f : 0x2.fp+4f :
+= sqrt tonearest flt-32 0x8.a1p+8f : 0x2.fp+4f :
+= sqrt towardzero flt-32 0x8.a1p+8f : 0x2.fp+4f :
+= sqrt upward flt-32 0x8.a1p+8f : 0x2.fp+4f :
+= sqrt downward dbl-64 0x8.a1p+8 : 0x2.fp+4 :
+= sqrt tonearest dbl-64 0x8.a1p+8 : 0x2.fp+4 :
+= sqrt towardzero dbl-64 0x8.a1p+8 : 0x2.fp+4 :
+= sqrt upward dbl-64 0x8.a1p+8 : 0x2.fp+4 :
+= sqrt downward ldbl-96-intel 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt tonearest ldbl-96-intel 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt towardzero ldbl-96-intel 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt upward ldbl-96-intel 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt downward ldbl-96-m68k 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt tonearest ldbl-96-m68k 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt towardzero ldbl-96-m68k 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt upward ldbl-96-m68k 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt downward ldbl-128 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt tonearest ldbl-128 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt towardzero ldbl-128 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt upward ldbl-128 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt downward ldbl-128ibm 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt tonearest ldbl-128ibm 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt towardzero ldbl-128ibm 0x8.a1p+8L : 0x2.fp+4L :
+= sqrt upward ldbl-128ibm 0x8.a1p+8L : 0x2.fp+4L :
+sqrt 4
+= sqrt downward flt-32 0x4p+0f : 0x2p+0f :
+= sqrt tonearest flt-32 0x4p+0f : 0x2p+0f :
+= sqrt towardzero flt-32 0x4p+0f : 0x2p+0f :
+= sqrt upward flt-32 0x4p+0f : 0x2p+0f :
+= sqrt downward dbl-64 0x4p+0 : 0x2p+0 :
+= sqrt tonearest dbl-64 0x4p+0 : 0x2p+0 :
+= sqrt towardzero dbl-64 0x4p+0 : 0x2p+0 :
+= sqrt upward dbl-64 0x4p+0 : 0x2p+0 :
+= sqrt downward ldbl-96-intel 0x4p+0L : 0x2p+0L :
+= sqrt tonearest ldbl-96-intel 0x4p+0L : 0x2p+0L :
+= sqrt towardzero ldbl-96-intel 0x4p+0L : 0x2p+0L :
+= sqrt upward ldbl-96-intel 0x4p+0L : 0x2p+0L :
+= sqrt downward ldbl-96-m68k 0x4p+0L : 0x2p+0L :
+= sqrt tonearest ldbl-96-m68k 0x4p+0L : 0x2p+0L :
+= sqrt towardzero ldbl-96-m68k 0x4p+0L : 0x2p+0L :
+= sqrt upward ldbl-96-m68k 0x4p+0L : 0x2p+0L :
+= sqrt downward ldbl-128 0x4p+0L : 0x2p+0L :
+= sqrt tonearest ldbl-128 0x4p+0L : 0x2p+0L :
+= sqrt towardzero ldbl-128 0x4p+0L : 0x2p+0L :
+= sqrt upward ldbl-128 0x4p+0L : 0x2p+0L :
+= sqrt downward ldbl-128ibm 0x4p+0L : 0x2p+0L :
+= sqrt tonearest ldbl-128ibm 0x4p+0L : 0x2p+0L :
+= sqrt towardzero ldbl-128ibm 0x4p+0L : 0x2p+0L :
+= sqrt upward ldbl-128ibm 0x4p+0L : 0x2p+0L :
+sqrt 2
+= sqrt downward flt-32 0x2p+0f : 0x1.6a09e6p+0f : inexact
+= sqrt tonearest flt-32 0x2p+0f : 0x1.6a09e6p+0f : inexact
+= sqrt towardzero flt-32 0x2p+0f : 0x1.6a09e6p+0f : inexact
+= sqrt upward flt-32 0x2p+0f : 0x1.6a09e8p+0f : inexact
+= sqrt downward dbl-64 0x2p+0 : 0x1.6a09e667f3bccp+0 : inexact
+= sqrt tonearest dbl-64 0x2p+0 : 0x1.6a09e667f3bcdp+0 : inexact
+= sqrt towardzero dbl-64 0x2p+0 : 0x1.6a09e667f3bccp+0 : inexact
+= sqrt upward dbl-64 0x2p+0 : 0x1.6a09e667f3bcdp+0 : inexact
+= sqrt downward ldbl-96-intel 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt tonearest ldbl-96-intel 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt towardzero ldbl-96-intel 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt upward ldbl-96-intel 0x2p+0L : 0x1.6a09e667f3bcc90ap+0L : inexact
+= sqrt downward ldbl-96-m68k 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt tonearest ldbl-96-m68k 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt towardzero ldbl-96-m68k 0x2p+0L : 0x1.6a09e667f3bcc908p+0L : inexact
+= sqrt upward ldbl-96-m68k 0x2p+0L : 0x1.6a09e667f3bcc90ap+0L : inexact
+= sqrt downward ldbl-128 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea95p+0L : inexact
+= sqrt tonearest ldbl-128 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea95p+0L : inexact
+= sqrt towardzero ldbl-128 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea95p+0L : inexact
+= sqrt upward ldbl-128 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea96p+0L : inexact
+= sqrt downward ldbl-128ibm 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea8p+0L : inexact
+= sqrt tonearest ldbl-128ibm 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea8p+0L : inexact
+= sqrt towardzero ldbl-128ibm 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ea8p+0L : inexact
+= sqrt upward ldbl-128ibm 0x2p+0L : 0x1.6a09e667f3bcc908b2fb1366ebp+0L : inexact
+sqrt 0.25
+= sqrt downward flt-32 0x4p-4f : 0x8p-4f :
+= sqrt tonearest flt-32 0x4p-4f : 0x8p-4f :
+= sqrt towardzero flt-32 0x4p-4f : 0x8p-4f :
+= sqrt upward flt-32 0x4p-4f : 0x8p-4f :
+= sqrt downward dbl-64 0x4p-4 : 0x8p-4 :
+= sqrt tonearest dbl-64 0x4p-4 : 0x8p-4 :
+= sqrt towardzero dbl-64 0x4p-4 : 0x8p-4 :
+= sqrt upward dbl-64 0x4p-4 : 0x8p-4 :
+= sqrt downward ldbl-96-intel 0x4p-4L : 0x8p-4L :
+= sqrt tonearest ldbl-96-intel 0x4p-4L : 0x8p-4L :
+= sqrt towardzero ldbl-96-intel 0x4p-4L : 0x8p-4L :
+= sqrt upward ldbl-96-intel 0x4p-4L : 0x8p-4L :
+= sqrt downward ldbl-96-m68k 0x4p-4L : 0x8p-4L :
+= sqrt tonearest ldbl-96-m68k 0x4p-4L : 0x8p-4L :
+= sqrt towardzero ldbl-96-m68k 0x4p-4L : 0x8p-4L :
+= sqrt upward ldbl-96-m68k 0x4p-4L : 0x8p-4L :
+= sqrt downward ldbl-128 0x4p-4L : 0x8p-4L :
+= sqrt tonearest ldbl-128 0x4p-4L : 0x8p-4L :
+= sqrt towardzero ldbl-128 0x4p-4L : 0x8p-4L :
+= sqrt upward ldbl-128 0x4p-4L : 0x8p-4L :
+= sqrt downward ldbl-128ibm 0x4p-4L : 0x8p-4L :
+= sqrt tonearest ldbl-128ibm 0x4p-4L : 0x8p-4L :
+= sqrt towardzero ldbl-128ibm 0x4p-4L : 0x8p-4L :
+= sqrt upward ldbl-128ibm 0x4p-4L : 0x8p-4L :
+sqrt 6642.25
+= sqrt downward flt-32 0x1.9f24p+12f : 0x5.18p+4f :
+= sqrt tonearest flt-32 0x1.9f24p+12f : 0x5.18p+4f :
+= sqrt towardzero flt-32 0x1.9f24p+12f : 0x5.18p+4f :
+= sqrt upward flt-32 0x1.9f24p+12f : 0x5.18p+4f :
+= sqrt downward dbl-64 0x1.9f24p+12 : 0x5.18p+4 :
+= sqrt tonearest dbl-64 0x1.9f24p+12 : 0x5.18p+4 :
+= sqrt towardzero dbl-64 0x1.9f24p+12 : 0x5.18p+4 :
+= sqrt upward dbl-64 0x1.9f24p+12 : 0x5.18p+4 :
+= sqrt downward ldbl-96-intel 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt tonearest ldbl-96-intel 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt towardzero ldbl-96-intel 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt upward ldbl-96-intel 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt downward ldbl-96-m68k 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt tonearest ldbl-96-m68k 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt towardzero ldbl-96-m68k 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt upward ldbl-96-m68k 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt downward ldbl-128 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt tonearest ldbl-128 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt towardzero ldbl-128 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt upward ldbl-128 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt downward ldbl-128ibm 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt tonearest ldbl-128ibm 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt towardzero ldbl-128ibm 0x1.9f24p+12L : 0x5.18p+4L :
+= sqrt upward ldbl-128ibm 0x1.9f24p+12L : 0x5.18p+4L :
+sqrt 15190.5625
+= sqrt downward flt-32 0x3.b569p+12f : 0x7.b4p+4f :
+= sqrt tonearest flt-32 0x3.b569p+12f : 0x7.b4p+4f :
+= sqrt towardzero flt-32 0x3.b569p+12f : 0x7.b4p+4f :
+= sqrt upward flt-32 0x3.b569p+12f : 0x7.b4p+4f :
+= sqrt downward dbl-64 0x3.b569p+12 : 0x7.b4p+4 :
+= sqrt tonearest dbl-64 0x3.b569p+12 : 0x7.b4p+4 :
+= sqrt towardzero dbl-64 0x3.b569p+12 : 0x7.b4p+4 :
+= sqrt upward dbl-64 0x3.b569p+12 : 0x7.b4p+4 :
+= sqrt downward ldbl-96-intel 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt tonearest ldbl-96-intel 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt towardzero ldbl-96-intel 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt upward ldbl-96-intel 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt downward ldbl-96-m68k 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt tonearest ldbl-96-m68k 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt towardzero ldbl-96-m68k 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt upward ldbl-96-m68k 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt downward ldbl-128 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt tonearest ldbl-128 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt towardzero ldbl-128 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt upward ldbl-128 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt downward ldbl-128ibm 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt tonearest ldbl-128ibm 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt towardzero ldbl-128ibm 0x3.b569p+12L : 0x7.b4p+4L :
+= sqrt upward ldbl-128ibm 0x3.b569p+12L : 0x7.b4p+4L :
+sqrt 0.75
+= sqrt downward flt-32 0xcp-4f : 0xd.db3d7p-4f : inexact
+= sqrt tonearest flt-32 0xcp-4f : 0xd.db3d7p-4f : inexact
+= sqrt towardzero flt-32 0xcp-4f : 0xd.db3d7p-4f : inexact
+= sqrt upward flt-32 0xcp-4f : 0xd.db3d8p-4f : inexact
+= sqrt downward dbl-64 0xcp-4 : 0xd.db3d742c2655p-4 : inexact
+= sqrt tonearest dbl-64 0xcp-4 : 0xd.db3d742c2655p-4 : inexact
+= sqrt towardzero dbl-64 0xcp-4 : 0xd.db3d742c2655p-4 : inexact
+= sqrt upward dbl-64 0xcp-4 : 0xd.db3d742c26558p-4 : inexact
+= sqrt downward ldbl-96-intel 0xcp-4L : 0xd.db3d742c265539dp-4L : inexact
+= sqrt tonearest ldbl-96-intel 0xcp-4L : 0xd.db3d742c265539ep-4L : inexact
+= sqrt towardzero ldbl-96-intel 0xcp-4L : 0xd.db3d742c265539dp-4L : inexact
+= sqrt upward ldbl-96-intel 0xcp-4L : 0xd.db3d742c265539ep-4L : inexact
+= sqrt downward ldbl-96-m68k 0xcp-4L : 0xd.db3d742c265539dp-4L : inexact
+= sqrt tonearest ldbl-96-m68k 0xcp-4L : 0xd.db3d742c265539ep-4L : inexact
+= sqrt towardzero ldbl-96-m68k 0xcp-4L : 0xd.db3d742c265539dp-4L : inexact
+= sqrt upward ldbl-96-m68k 0xcp-4L : 0xd.db3d742c265539ep-4L : inexact
+= sqrt downward ldbl-128 0xcp-4L : 0xd.db3d742c265539d92ba16b83c5cp-4L : inexact
+= sqrt tonearest ldbl-128 0xcp-4L : 0xd.db3d742c265539d92ba16b83c5cp-4L : inexact
+= sqrt towardzero ldbl-128 0xcp-4L : 0xd.db3d742c265539d92ba16b83c5cp-4L : inexact
+= sqrt upward ldbl-128 0xcp-4L : 0xd.db3d742c265539d92ba16b83c5c8p-4L : inexact
+= sqrt downward ldbl-128ibm 0xcp-4L : 0xd.db3d742c265539d92ba16b83c4p-4L : inexact
+= sqrt tonearest ldbl-128ibm 0xcp-4L : 0xd.db3d742c265539d92ba16b83c4p-4L : inexact
+= sqrt towardzero ldbl-128ibm 0xcp-4L : 0xd.db3d742c265539d92ba16b83c4p-4L : inexact
+= sqrt upward ldbl-128ibm 0xcp-4L : 0xd.db3d742c265539d92ba16b83c8p-4L : inexact
--- /dev/null
+/* Generate expected output for libm tests with MPFR and MPC.
+ Copyright (C) 2013 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+/* Compile this program as:
+
+ gcc -std=gnu99 -O2 -Wall -Wextra gen-auto-libm-tests.c -lmpc -lmpfr -lgmp \
+ -o gen-auto-libm-tests
+
+ (use of current MPC and MPFR versions recommended) and run it as:
+
+ gen-auto-libm-tests auto-libm-test-in auto-libm-test-out
+
+ The input file auto-libm-test-in contains three kinds of lines:
+
+ Lines beginning with "#" are comments, and are ignored, as are
+ empty lines.
+
+ Other lines are test lines, of the form "function input1 input2
+ ... [flag1 flag2 ...]". Inputs are either finite real numbers or
+ integers, depending on the function under test. Real numbers may
+ be in any form acceptable to mpfr_strtofr (base 0); integers in any
+ form acceptable to mpz_set_str (base 0). In addition, real numbers
+ may be certain special strings such as "pi", as listed in the
+ special_real_inputs array.
+
+ Each flag is a flag name possibly followed by a series of
+ ":condition". Conditions may be any of the names of floating-point
+ formats in the floating_point_formats array, "long32" and "long64"
+ to indicate the number of bits in the "long" type, or other strings
+ for which libm-test.inc defines a TEST_COND_<condition> macro (with
+ "-"- changed to "_" in the condition name) evaluating to nonzero
+ when the condition is true and zero when the condition is false.
+ The meaning is that the flag applies to the test if all the listed
+ conditions are true. "flag:cond1:cond2 flag:cond3:cond4" means the
+ flag applies if ((cond1 && cond2) || (cond3 && cond4)).
+
+ A real number specified as an input is considered to represent the
+ set of real numbers arising from rounding the given number in any
+ direction for any supported floating-point format; any roundings
+ that give infinity are ignored. Each input on a test line has all
+ the possible roundings considered independently. Each resulting
+ choice of the tuple of inputs to the function is ignored if the
+ mathematical result of the function involves a NaN or an exact
+ infinity, and is otherwise considered for each floating-point
+ format for which all those inputs are exactly representable. Thus
+ tests may result in "overflow", "underflow" and "inexact"
+ exceptions; "invalid" may arise only when the final result type is
+ an integer type and it is the conversion of a mathematically
+ defined finite result to integer type that results in that
+ exception.
+
+ By default, it is assumed that "overflow" and "underflow"
+ exceptions should be correct, but that "inexact" exceptions should
+ only be correct for functions listed as exactly determined. For
+ such functions, "underflow" exceptions should respect whether the
+ machine has before-rounding or after-rounding tininess detection.
+ For other functions, it is considered that if the exact result is
+ somewhere between the greatest magnitude subnormal of a given sign
+ (exclusive) and the least magnitude normal of that sign
+ (inclusive), underflow exceptions are permitted but optional on all
+ machines, and they are also permitted but optional for smaller
+ subnormal exact results for functions that are not exactly
+ determined. errno setting is expected for overflow to infinity and
+ underflow to zero (for real functions), and for out-of-range
+ conversion of a finite result to integer type, and is considered
+ permitted but optional for all other cases where overflow
+ exceptions occur, and where underflow exceptions occur or are
+ permitted. In other cases (where no overflow or underflow is
+ permitted), errno is expected to be left unchanged.
+
+ The flag "no-test-inline" indicates a test is disabled for inline
+ function testing; "xfail" indicates the test is disabled as
+ expected to produce incorrect results. Otherwise, test flags are
+ of the form "spurious-<exception>" and "missing-<exception>", for
+ any exception ("overflow", "underflow", "inexact", "invalid",
+ "divbyzero"), "spurious-errno" and "missing-errno", to indicate
+ when tests are expected to deviate from the exception and errno
+ settings corresponding to the mathematical results. "xfail",
+ "spurious-" and "missing-" flags should be accompanied by a comment
+ referring to an open bug in glibc Bugzilla.
+
+ The output file auto-libm-test-out contains the test lines from
+ auto-libm-test-in, and, after the line for a given test, some
+ number of output test lines. An output test line is of the form "=
+ function rounding-mode format input1 input2 ... : output1 output2
+ ... : flags". rounding-mode is "tonearest", "towardzero", "upward"
+ or "downward". format is a name from the floating_point_formats
+ array, possibly followed by a sequence of ":flag" for flags from
+ "long32", "long64", "before-rounding" and "after-rounding" (the
+ last two indicating tests where expectations for underflow
+ exceptions depend on how the architecture detects tininess).
+ Inputs and outputs are specified as hex floats with the required
+ suffix for the floating-point type, or plus_infty or minus_infty
+ for infinite expected results, or as integer constant expressions
+ (not necessarily with the right type) or IGNORE for integer inputs
+ and outputs. Flags are "no-test-inline", "xfail", "<exception>",
+ "<exception>-ok", "errno-<value>", "errno-<value>-ok", where
+ "<exception>" and "errno-<value>" are unconditional, indicating
+ that a correct result means the given exception should be raised or
+ errno should be set to the given value, and other settings may be
+ conditional or unconditional; "-ok" means not to test for the given
+ exception or errno value (whether because it was marked as possibly
+ missing or spurious, or because the calculation of correct results
+ indicated it was optional). */
+
+#define _GNU_SOURCE
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <error.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gmp.h>
+#include <mpfr.h>
+#include <mpc.h>
+
+#define ARRAY_SIZE(A) (sizeof (A) / sizeof ((A)[0]))
+
+/* The supported floating-point formats. */
+typedef enum
+ {
+ fp_flt_32,
+ fp_dbl_64,
+ fp_ldbl_96_intel,
+ fp_ldbl_96_m68k,
+ fp_ldbl_128,
+ fp_ldbl_128ibm,
+ fp_num_formats,
+ fp_first_format = 0
+ } fp_format;
+
+/* Structure describing a single floating-point format. */
+typedef struct
+{
+ /* The name of the format. */
+ const char *name;
+ /* The suffix to use on floating-point constants with this
+ format. */
+ const char *suffix;
+ /* A string for the largest normal value, or NULL for IEEE formats
+ where this can be determined automatically. */
+ const char *max_string;
+ /* The number of mantissa bits. */
+ int mant_dig;
+ /* The least N such that 2^N overflows. */
+ int max_exp;
+ /* One more than the least N such that 2^N is normal. */
+ int min_exp;
+ /* The largest normal value. */
+ mpfr_t max;
+ /* The least positive normal value, 2^(MIN_EXP-1). */
+ mpfr_t min;
+ /* The greatest positive subnormal value. */
+ mpfr_t subnorm_max;
+ /* The least positive subnormal value, 2^(MIN_EXP-MANT_DIG). */
+ mpfr_t subnorm_min;
+} fp_format_desc;
+
+/* List of floating-point formats, in the same order as the fp_format
+ enumeration. */
+static fp_format_desc fp_formats[fp_num_formats] =
+ {
+ { "flt-32", "f", NULL, 24, 128, -125, {}, {}, {}, {} },
+ { "dbl-64", "", NULL, 53, 1024, -1021, {}, {}, {}, {} },
+ { "ldbl-96-intel", "L", NULL, 64, 16384, -16381, {}, {}, {}, {} },
+ { "ldbl-96-m68k", "L", NULL, 64, 16384, -16382, {}, {}, {}, {} },
+ { "ldbl-128", "L", NULL, 113, 16384, -16381, {}, {}, {}, {} },
+ { "ldbl-128ibm", "L", "0x1.fffffffffffff7ffffffffffff8p+1023",
+ 106, 1024, -968, {}, {}, {}, {} },
+ };
+
+/* The supported rounding modes. */
+typedef enum
+ {
+ rm_downward,
+ rm_tonearest,
+ rm_towardzero,
+ rm_upward,
+ rm_num_modes,
+ rm_first_mode = 0
+ } rounding_mode;
+
+/* Structure describing a single rounding mode. */
+typedef struct
+{
+ /* The name of the rounding mode. */
+ const char *name;
+ /* The MPFR rounding mode. */
+ mpfr_rnd_t mpfr_mode;
+} rounding_mode_desc;
+
+/* List of rounding modes, in the same order as the rounding_mode
+ enumeration. */
+static const rounding_mode_desc rounding_modes[rm_num_modes] =
+ {
+ { "downward", MPFR_RNDD },
+ { "tonearest", MPFR_RNDN },
+ { "towardzero", MPFR_RNDZ },
+ { "upward", MPFR_RNDU },
+ };
+
+/* The supported exceptions. */
+typedef enum
+ {
+ exc_divbyzero,
+ exc_inexact,
+ exc_invalid,
+ exc_overflow,
+ exc_underflow,
+ exc_num_exceptions,
+ exc_first_exception = 0
+ } fp_exception;
+
+/* List of exceptions, in the same order as the fp_exception
+ enumeration. */
+static const char *const exceptions[exc_num_exceptions] =
+ {
+ "divbyzero",
+ "inexact",
+ "invalid",
+ "overflow",
+ "underflow",
+ };
+
+/* The internal precision to use for most MPFR calculations, which
+ must be at least 2 more than the greatest precision of any
+ supported floating-point format. */
+static int internal_precision;
+
+/* A value that overflows all supported floating-point formats. */
+static mpfr_t global_max;
+
+/* A value that is at most half the least subnormal in any
+ floating-point format and so is rounded the same way as all
+ sufficiently small positive values. */
+static mpfr_t global_min;
+
+/* The maximum number of (real or integer) arguments to a function
+ handled by this program (complex arguments count as two real
+ arguments). */
+#define MAX_NARGS 4
+
+/* The maximum number of (real or integer) return values from a
+ function handled by this program. */
+#define MAX_NRET 2
+
+/* A type of a function argument or return value. */
+typedef enum
+ {
+ /* No type (not a valid argument or return value). */
+ type_none,
+ /* A floating-point value with the type corresponding to that of
+ the function. */
+ type_fp,
+ /* An integer value of type int. */
+ type_int,
+ /* An integer value of type long. */
+ type_long,
+ /* An integer value of type long long. */
+ type_long_long,
+ } arg_ret_type;
+
+/* A type of a generic real or integer value. */
+typedef enum
+ {
+ /* No type. */
+ gtype_none,
+ /* Floating-point (represented with MPFR). */
+ gtype_fp,
+ /* Integer (represented with GMP). */
+ gtype_int,
+ } generic_value_type;
+
+/* A generic value (argument or result). */
+typedef struct
+{
+ /* The type of this value. */
+ generic_value_type type;
+ /* Its value. */
+ union
+ {
+ mpfr_t f;
+ mpz_t i;
+ } value;
+} generic_value;
+
+/* A type of input flag. */
+typedef enum
+ {
+ flag_no_test_inline,
+ flag_xfail,
+ /* The "spurious" and "missing" flags must be in the same order as
+ the fp_exception enumeration. */
+ flag_spurious_divbyzero,
+ flag_spurious_inexact,
+ flag_spurious_invalid,
+ flag_spurious_overflow,
+ flag_spurious_underflow,
+ flag_spurious_errno,
+ flag_missing_divbyzero,
+ flag_missing_inexact,
+ flag_missing_invalid,
+ flag_missing_overflow,
+ flag_missing_underflow,
+ flag_missing_errno,
+ num_input_flag_types,
+ flag_first_flag = 0,
+ flag_spurious_first = flag_spurious_divbyzero,
+ flag_missing_first = flag_missing_divbyzero
+ } input_flag_type;
+
+/* List of flags, in the same order as the input_flag_type
+ enumeration. */
+static const char *const input_flags[num_input_flag_types] =
+ {
+ "no-test-inline",
+ "xfail",
+ "spurious-divbyzero",
+ "spurious-inexact",
+ "spurious-invalid",
+ "spurious-overflow",
+ "spurious-underflow",
+ "spurious-errno",
+ "missing-divbyzero",
+ "missing-inexact",
+ "missing-invalid",
+ "missing-overflow",
+ "missing-underflow",
+ "missing-errno",
+ };
+
+/* An input flag, possibly conditional. */
+typedef struct
+{
+ /* The type of this flag. */
+ input_flag_type type;
+ /* The conditions on this flag, as a string ":cond1:cond2..." or
+ NULL. */
+ const char *cond;
+} input_flag;
+
+/* Structure describing a single test from the input file (which may
+ expand into many tests in the output). The choice of function,
+ which implies the numbers and types of arguments and results, is
+ implicit rather than stored in this structure (except as part of
+ the source line). */
+typedef struct
+{
+ /* The text of the input line describing the test, including the
+ trailing newline. */
+ const char *line;
+ /* The number of combinations of interpretations of input values for
+ different floating-point formats and rounding modes. */
+ size_t num_input_cases;
+ /* The corresponding lists of inputs. */
+ generic_value **inputs;
+ /* The number of flags for this test. */
+ size_t num_flags;
+ /* The corresponding list of flags. */
+ input_flag *flags;
+ /* The old output for this test. */
+ const char *old_output;
+} input_test;
+
+/* Ways to calculate a function. */
+typedef enum
+ {
+ /* MPFR function with a single argument and result. */
+ mpfr_f_f,
+ } func_calc_method;
+
+/* Description of how to calculate a function. */
+typedef struct
+{
+ /* Which method is used to calculate the function. */
+ func_calc_method method;
+ /* The specific function called. */
+ union
+ {
+ int (*mpfr_f_f) (mpfr_t, const mpfr_t, mpfr_rnd_t);
+ } func;
+} func_calc_desc;
+
+/* Structure describing a function handled by this program. */
+typedef struct
+{
+ /* The name of the function. */
+ const char *name;
+ /* The number of arguments. */
+ size_t num_args;
+ /* The types of the arguments. */
+ arg_ret_type arg_types[MAX_NARGS];
+ /* The number of return values. */
+ size_t num_ret;
+ /* The types of the return values. */
+ arg_ret_type ret_types[MAX_NRET];
+ /* Whether the function has exactly determined results and
+ exceptions. */
+ bool exact;
+ /* Whether the function is a complex function, so errno setting is
+ optional. */
+ bool complex_fn;
+ /* How to calculate this function. */
+ func_calc_desc calc;
+ /* The number of tests allocated for this function. */
+ size_t num_tests_alloc;
+ /* The number of tests for this function. */
+ size_t num_tests;
+ /* The tests themselves. */
+ input_test *tests;
+} test_function;
+
+#define FUNC_mpfr_f_f(NAME, MPFR_FUNC, EXACT) \
+ { \
+ NAME, 1, { type_fp }, 1, { type_fp }, EXACT, false, \
+ { mpfr_f_f, { .mpfr_f_f = MPFR_FUNC } }, 0, 0, NULL \
+ }
+
+/* List of functions handled by this program. */
+static test_function test_functions[] =
+ {
+ FUNC_mpfr_f_f ("sqrt", mpfr_sqrt, true),
+ };
+
+/* Allocate memory, with error checking. */
+
+static void *
+xmalloc (size_t n)
+{
+ void *p = malloc (n);
+ if (p == NULL)
+ error (EXIT_FAILURE, errno, "xmalloc failed");
+ return p;
+}
+
+static void *
+xrealloc (void *p, size_t n)
+{
+ p = realloc (p, n);
+ if (p == NULL)
+ error (EXIT_FAILURE, errno, "xrealloc failed");
+ return p;
+}
+
+static char *
+xstrdup (const char *s)
+{
+ char *p = strdup (s);
+ if (p == NULL)
+ error (EXIT_FAILURE, errno, "xstrdup failed");
+ return p;
+}
+
+/* Assert that the result of an MPFR operation was exact; that is,
+ that the returned ternary value was 0. */
+
+static void
+assert_exact (int i)
+{
+ assert (i == 0);
+}
+
+/* Return the generic type of an argument or return value type T. */
+
+static generic_value_type
+generic_arg_ret_type (arg_ret_type t)
+{
+ switch (t)
+ {
+ case type_fp:
+ return gtype_fp;
+
+ case type_int:
+ case type_long:
+ case type_long_long:
+ return gtype_int;
+
+ default:
+ abort ();
+ }
+}
+
+/* Free a generic_value *V. */
+
+static void
+generic_value_free (generic_value *v)
+{
+ switch (v->type)
+ {
+ case gtype_fp:
+ mpfr_clear (v->value.f);
+ break;
+
+ case gtype_int:
+ mpz_clear (v->value.i);
+ break;
+
+ default:
+ abort ();
+ }
+}
+
+/* Copy a generic_value *SRC to *DEST. */
+
+static void
+generic_value_copy (generic_value *dest, const generic_value *src)
+{
+ dest->type = src->type;
+ switch (src->type)
+ {
+ case gtype_fp:
+ mpfr_init (dest->value.f);
+ assert_exact (mpfr_set (dest->value.f, src->value.f, MPFR_RNDN));
+ break;
+
+ case gtype_int:
+ mpz_init (dest->value.i);
+ mpz_set (dest->value.i, src->value.i);
+ break;
+
+ default:
+ abort ();
+ }
+}
+
+/* Initialize data for floating-point formats. */
+
+static void
+init_fp_formats ()
+{
+ int global_max_exp = 0, global_min_subnorm_exp = 0;
+ for (fp_format f = fp_first_format; f < fp_num_formats; f++)
+ {
+ if (fp_formats[f].mant_dig + 2 > internal_precision)
+ internal_precision = fp_formats[f].mant_dig + 2;
+ if (fp_formats[f].max_exp > global_max_exp)
+ global_max_exp = fp_formats[f].max_exp;
+ int min_subnorm_exp = fp_formats[f].min_exp - fp_formats[f].mant_dig;
+ if (min_subnorm_exp < global_min_subnorm_exp)
+ global_min_subnorm_exp = min_subnorm_exp;
+ mpfr_init2 (fp_formats[f].max, fp_formats[f].mant_dig);
+ if (fp_formats[f].max_string != NULL)
+ {
+ char *ep = NULL;
+ assert_exact (mpfr_strtofr (fp_formats[f].max,
+ fp_formats[f].max_string,
+ &ep, 0, MPFR_RNDN));
+ assert (*ep == 0);
+ }
+ else
+ {
+ assert_exact (mpfr_set_ui_2exp (fp_formats[f].max, 1,
+ fp_formats[f].max_exp,
+ MPFR_RNDN));
+ mpfr_nextbelow (fp_formats[f].max);
+ }
+ mpfr_init2 (fp_formats[f].min, fp_formats[f].mant_dig);
+ assert_exact (mpfr_set_ui_2exp (fp_formats[f].min, 1,
+ fp_formats[f].min_exp - 1,
+ MPFR_RNDN));
+ mpfr_init2 (fp_formats[f].subnorm_max, fp_formats[f].mant_dig);
+ assert_exact (mpfr_set (fp_formats[f].subnorm_max, fp_formats[f].min,
+ MPFR_RNDN));
+ mpfr_nextbelow (fp_formats[f].subnorm_max);
+ mpfr_nextbelow (fp_formats[f].subnorm_max);
+ mpfr_init2 (fp_formats[f].subnorm_min, fp_formats[f].mant_dig);
+ assert_exact (mpfr_set_ui_2exp (fp_formats[f].subnorm_min, 1,
+ min_subnorm_exp, MPFR_RNDN));
+ }
+ mpfr_set_default_prec (internal_precision);
+ mpfr_init (global_max);
+ assert_exact (mpfr_set_ui_2exp (global_max, 1, global_max_exp, MPFR_RNDN));
+ mpfr_init (global_min);
+ assert_exact (mpfr_set_ui_2exp (global_min, 1, global_min_subnorm_exp - 1,
+ MPFR_RNDN));
+}
+
+/* Fill in mpfr_t values for special strings in input arguments. */
+
+static size_t
+special_fill_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
+ fp_format format)
+{
+ mpfr_init2 (res0, fp_formats[format].mant_dig);
+ assert_exact (mpfr_set (res0, fp_formats[format].max, MPFR_RNDN));
+ return 1;
+}
+
+static size_t
+special_fill_minus_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),
+ fp_format format)
+{
+ mpfr_init2 (res0, fp_formats[format].mant_dig);
+ assert_exact (mpfr_neg (res0, fp_formats[format].max, MPFR_RNDN));
+ return 1;
+}
+
+static size_t
+special_fill_pi (mpfr_t res0, mpfr_t res1, fp_format format)
+{
+ mpfr_init2 (res0, fp_formats[format].mant_dig);
+ mpfr_const_pi (res0, MPFR_RNDU);
+ mpfr_init2 (res1, fp_formats[format].mant_dig);
+ mpfr_const_pi (res1, MPFR_RNDD);
+ return 2;
+}
+
+static size_t
+special_fill_minus_pi (mpfr_t res0, mpfr_t res1, fp_format format)
+{
+ mpfr_init2 (res0, fp_formats[format].mant_dig);
+ mpfr_const_pi (res0, MPFR_RNDU);
+ assert_exact (mpfr_neg (res0, res0, MPFR_RNDN));
+ mpfr_init2 (res1, fp_formats[format].mant_dig);
+ mpfr_const_pi (res1, MPFR_RNDD);
+ assert_exact (mpfr_neg (res1, res1, MPFR_RNDN));
+ return 2;
+}
+
+/* A special string accepted in input arguments. */
+typedef struct
+{
+ /* The string. */
+ const char *str;
+ /* The function that interprets it for a given floating-point
+ format, filling in up to two mpfr_t values and returning the
+ number of values filled. */
+ size_t (*func) (mpfr_t, mpfr_t, fp_format);
+} special_real_input;
+
+/* List of special strings accepted in input arguments. */
+
+static const special_real_input special_real_inputs[] =
+ {
+ { "max", special_fill_max },
+ { "-max", special_fill_minus_max },
+ { "pi", special_fill_pi },
+ { "-pi", special_fill_minus_pi },
+ };
+
+/* Given a real number R computed in round-to-zero mode, set the
+ lowest bit as a sticky bit if INEXACT, and saturate the exponent
+ range for very large or small values. */
+
+static void
+adjust_real (mpfr_t r, bool inexact)
+{
+ if (!inexact)
+ return;
+ /* NaNs are exact, as are infinities in round-to-zero mode. */
+ assert (mpfr_regular_p (r));
+ if (mpfr_cmpabs (r, global_min) < 0)
+ assert_exact (mpfr_copysign (r, global_min, r, MPFR_RNDN));
+ else if (mpfr_cmpabs (r, global_max) > 0)
+ assert_exact (mpfr_copysign (r, global_max, r, MPFR_RNDN));
+ else
+ {
+ mpz_t tmp;
+ mpz_init (tmp);
+ mpfr_exp_t e = mpfr_get_z_2exp (tmp, r);
+ mpz_setbit (tmp, 0);
+ assert_exact (mpfr_set_z_2exp (r, tmp, e, MPFR_RNDN));
+ mpz_clear (tmp);
+ }
+}
+
+/* Given a finite real number R with sticky bit, compute the roundings
+ to FORMAT in each rounding mode, storing the results in RES, the
+ before-rounding exceptions in EXC_BEFORE and the after-rounding
+ exceptions in EXC_AFTER. */
+
+static void
+round_real (mpfr_t res[rm_num_modes],
+ unsigned int exc_before[rm_num_modes],
+ unsigned int exc_after[rm_num_modes],
+ mpfr_t r, fp_format format)
+{
+ assert (mpfr_number_p (r));
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ {
+ mpfr_init2 (res[m], fp_formats[format].mant_dig);
+ exc_before[m] = exc_after[m] = 0;
+ bool inexact = mpfr_set (res[m], r, rounding_modes[m].mpfr_mode);
+ if (mpfr_cmpabs (res[m], fp_formats[format].max) > 0)
+ {
+ inexact = true;
+ exc_before[m] |= 1U << exc_overflow;
+ exc_after[m] |= 1U << exc_overflow;
+ bool overflow_inf;
+ switch (m)
+ {
+ case rm_tonearest:
+ overflow_inf = true;
+ break;
+ case rm_towardzero:
+ overflow_inf = false;
+ break;
+ case rm_downward:
+ overflow_inf = mpfr_signbit (res[m]);
+ break;
+ case rm_upward:
+ overflow_inf = !mpfr_signbit (res[m]);
+ break;
+ default:
+ abort ();
+ }
+ if (overflow_inf)
+ mpfr_set_inf (res[m], mpfr_signbit (res[m]) ? -1 : 1);
+ else
+ assert_exact (mpfr_copysign (res[m], fp_formats[format].max,
+ res[m], MPFR_RNDN));
+ }
+ if (mpfr_cmpabs (r, fp_formats[format].min) < 0)
+ {
+ /* Tiny before rounding; may or may not be tiny after
+ rounding, and underflow applies only if also inexact
+ around rounding to a possibly subnormal value. */
+ bool tiny_after_rounding
+ = mpfr_cmpabs (res[m], fp_formats[format].min) < 0;
+ /* To round to a possibly subnormal value, and determine
+ inexactness as a subnormal in the process, scale up and
+ round to integer, then scale back down. */
+ mpfr_t tmp;
+ mpfr_init (tmp);
+ assert_exact (mpfr_mul_2si (tmp, r, (fp_formats[format].mant_dig
+ - fp_formats[format].min_exp),
+ MPFR_RNDN));
+ int rint_res = mpfr_rint (tmp, tmp, rounding_modes[m].mpfr_mode);
+ /* The integer must be representable. */
+ assert (rint_res == 0 || rint_res == 2 || rint_res == -2);
+ /* If rounding to full precision was inexact, so must
+ rounding to subnormal precision be inexact. */
+ if (inexact)
+ assert (rint_res != 0);
+ else
+ inexact = rint_res != 0;
+ assert_exact (mpfr_mul_2si (res[m], tmp,
+ (fp_formats[format].min_exp
+ - fp_formats[format].mant_dig),
+ MPFR_RNDN));
+ mpfr_clear (tmp);
+ if (inexact)
+ {
+ exc_before[m] |= 1U << exc_underflow;
+ if (tiny_after_rounding)
+ exc_after[m] |= 1U << exc_underflow;
+ }
+ }
+ if (inexact)
+ {
+ exc_before[m] |= 1U << exc_inexact;
+ exc_after[m] |= 1U << exc_inexact;
+ }
+ }
+}
+
+/* Handle the input argument at ARG (NUL-terminated), updating the
+ lists of test inputs in IT accordingly. NUM_PREV_ARGS arguments
+ are already in those lists. The argument, of type GTYPE, comes
+ from file FILENAME, line LINENO. */
+
+static void
+handle_input_arg (const char *arg, input_test *it, size_t num_prev_args,
+ generic_value_type gtype,
+ const char *filename, unsigned int lineno)
+{
+ size_t num_values = 0;
+ generic_value values[2 * fp_num_formats];
+ switch (gtype)
+ {
+ case gtype_fp:
+ for (fp_format f = fp_first_format; f < fp_num_formats; f++)
+ {
+ mpfr_t extra_values[2];
+ size_t num_extra_values = 0;
+ for (size_t i = 0; i < ARRAY_SIZE (special_real_inputs); i++)
+ {
+ if (strcmp (arg, special_real_inputs[i].str) == 0)
+ {
+ num_extra_values
+ = special_real_inputs[i].func (extra_values[0],
+ extra_values[1], f);
+ assert (num_extra_values > 0
+ && num_extra_values <= ARRAY_SIZE (extra_values));
+ break;
+ }
+ }
+ if (num_extra_values == 0)
+ {
+ mpfr_t tmp;
+ char *ep;
+ mpfr_init (tmp);
+ bool inexact = mpfr_strtofr (tmp, arg, &ep, 0, MPFR_RNDZ);
+ if (*ep != 0 || !mpfr_number_p (tmp))
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "bad floating-point argument: '%s'", arg);
+ adjust_real (tmp, inexact);
+ mpfr_t rounded[rm_num_modes];
+ unsigned int exc_before[rm_num_modes];
+ unsigned int exc_after[rm_num_modes];
+ round_real (rounded, exc_before, exc_after, tmp, f);
+ mpfr_clear (tmp);
+ if (mpfr_number_p (rounded[rm_upward]))
+ {
+ mpfr_init2 (extra_values[num_extra_values],
+ fp_formats[f].mant_dig);
+ assert_exact (mpfr_set (extra_values[num_extra_values],
+ rounded[rm_upward], MPFR_RNDN));
+ num_extra_values++;
+ }
+ if (mpfr_number_p (rounded[rm_downward]))
+ {
+ mpfr_init2 (extra_values[num_extra_values],
+ fp_formats[f].mant_dig);
+ assert_exact (mpfr_set (extra_values[num_extra_values],
+ rounded[rm_downward], MPFR_RNDN));
+ num_extra_values++;
+ }
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ mpfr_clear (rounded[m]);
+ }
+ for (size_t i = 0; i < num_extra_values; i++)
+ {
+ bool found = false;
+ for (size_t j = 0; j < num_values; j++)
+ {
+ if (mpfr_equal_p (values[j].value.f, extra_values[i])
+ && ((mpfr_signbit (values[j].value.f) != 0)
+ == (mpfr_signbit (extra_values[i]) != 0)))
+ {
+ found = true;
+ break;
+ }
+ }
+ if (!found)
+ {
+ assert (num_values < ARRAY_SIZE (values));
+ values[num_values].type = gtype_fp;
+ mpfr_init2 (values[num_values].value.f,
+ fp_formats[f].mant_dig);
+ assert_exact (mpfr_set (values[num_values].value.f,
+ extra_values[i], MPFR_RNDN));
+ num_values++;
+ }
+ mpfr_clear (extra_values[i]);
+ }
+ }
+ break;
+
+ case gtype_int:
+ num_values = 1;
+ values[0].type = gtype_int;
+ int ret = mpz_init_set_str (values[0].value.i, arg, 0);
+ if (ret != 0)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "bad integer argument: '%s'", arg);
+ break;
+
+ default:
+ abort ();
+ }
+ assert (num_values > 0 && num_values <= ARRAY_SIZE (values));
+ if (it->num_input_cases >= SIZE_MAX / num_values)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno, "too many input cases");
+ generic_value **old_inputs = it->inputs;
+ size_t new_num_input_cases = it->num_input_cases * num_values;
+ generic_value **new_inputs = xmalloc (new_num_input_cases
+ * sizeof (new_inputs[0]));
+ for (size_t i = 0; i < it->num_input_cases; i++)
+ {
+ for (size_t j = 0; j < num_values; j++)
+ {
+ size_t idx = i * num_values + j;
+ new_inputs[idx] = xmalloc ((num_prev_args + 1)
+ * sizeof (new_inputs[idx][0]));
+ for (size_t k = 0; k < num_prev_args; k++)
+ generic_value_copy (&new_inputs[idx][k], &old_inputs[i][k]);
+ generic_value_copy (&new_inputs[idx][num_prev_args], &values[j]);
+ }
+ for (size_t j = 0; j < num_prev_args; j++)
+ generic_value_free (&old_inputs[i][j]);
+ free (old_inputs[i]);
+ }
+ free (old_inputs);
+ for (size_t i = 0; i < num_values; i++)
+ generic_value_free (&values[i]);
+ it->inputs = new_inputs;
+ it->num_input_cases = new_num_input_cases;
+}
+
+/* Handle the input flag ARG (NUL-terminated), storing it in *FLAG.
+ The flag comes from file FILENAME, line LINENO. */
+
+static void
+handle_input_flag (char *arg, input_flag *flag,
+ const char *filename, unsigned int lineno)
+{
+ char *ep = strchr (arg, ':');
+ if (ep == NULL)
+ {
+ ep = strchr (arg, 0);
+ assert (ep != NULL);
+ }
+ char c = *ep;
+ *ep = 0;
+ bool found = false;
+ for (input_flag_type i = flag_first_flag; i <= num_input_flag_types; i++)
+ {
+ if (strcmp (arg, input_flags[i]) == 0)
+ {
+ found = true;
+ flag->type = i;
+ break;
+ }
+ }
+ if (!found)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno, "unknown flag: '%s'",
+ arg);
+ *ep = c;
+ if (c == 0)
+ flag->cond = NULL;
+ else
+ flag->cond = xstrdup (ep);
+}
+
+/* Add the test LINE (file FILENAME, line LINENO) to the test
+ data. */
+
+static void
+add_test (char *line, const char *filename, unsigned int lineno)
+{
+ size_t num_tokens = 1;
+ char *p = line;
+ while ((p = strchr (p, ' ')) != NULL)
+ {
+ num_tokens++;
+ p++;
+ }
+ if (num_tokens < 2)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "line too short: '%s'", line);
+ p = strchr (line, ' ');
+ size_t func_name_len = p - line;
+ for (size_t i = 0; i < ARRAY_SIZE (test_functions); i++)
+ {
+ if (func_name_len == strlen (test_functions[i].name)
+ && strncmp (line, test_functions[i].name, func_name_len) == 0)
+ {
+ test_function *tf = &test_functions[i];
+ if (num_tokens < 1 + tf->num_args)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "line too short: '%s'", line);
+ if (tf->num_tests == tf->num_tests_alloc)
+ {
+ tf->num_tests_alloc = 2 * tf->num_tests_alloc + 16;
+ tf->tests
+ = xrealloc (tf->tests,
+ tf->num_tests_alloc * sizeof (tf->tests[0]));
+ }
+ input_test *it = &tf->tests[tf->num_tests];
+ it->line = line;
+ it->num_input_cases = 1;
+ it->inputs = xmalloc (sizeof (it->inputs[0]));
+ it->inputs[0] = NULL;
+ it->old_output = NULL;
+ p++;
+ for (size_t j = 0; j < tf->num_args; j++)
+ {
+ char *ep = strchr (p, ' ');
+ if (ep == NULL)
+ {
+ ep = strchr (p, '\n');
+ assert (ep != NULL);
+ }
+ if (ep == p)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "empty token in line: '%s'", line);
+ for (char *t = p; t < ep; t++)
+ if (isspace ((unsigned char) *t))
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "whitespace in token in line: '%s'", line);
+ char c = *ep;
+ *ep = 0;
+ handle_input_arg (p, it, j,
+ generic_arg_ret_type (tf->arg_types[j]),
+ filename, lineno);
+ *ep = c;
+ p = ep + 1;
+ }
+ it->num_flags = num_tokens - 1 - tf->num_args;
+ it->flags = xmalloc (it->num_flags * sizeof (it->flags[0]));
+ for (size_t j = 0; j < it->num_flags; j++)
+ {
+ char *ep = strchr (p, ' ');
+ if (ep == NULL)
+ {
+ ep = strchr (p, '\n');
+ assert (ep != NULL);
+ }
+ if (ep == p)
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "empty token in line: '%s'", line);
+ for (char *t = p; t < ep; t++)
+ if (isspace ((unsigned char) *t))
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "whitespace in token in line: '%s'", line);
+ char c = *ep;
+ *ep = 0;
+ handle_input_flag (p, &it->flags[j], filename, lineno);
+ *ep = c;
+ p = ep + 1;
+ }
+ assert (*p == 0);
+ tf->num_tests++;
+ return;
+ }
+ }
+ error_at_line (EXIT_FAILURE, 0, filename, lineno,
+ "unknown function in line: '%s'", line);
+}
+
+/* Read in the test input data from FILENAME. */
+
+static void
+read_input (const char *filename)
+{
+ FILE *fp = fopen (filename, "r");
+ if (fp == NULL)
+ error (EXIT_FAILURE, errno, "open '%s'", filename);
+ unsigned int lineno = 0;
+ for (;;)
+ {
+ size_t size = 0;
+ char *line = NULL;
+ ssize_t ret = getline (&line, &size, fp);
+ if (ret == -1)
+ break;
+ lineno++;
+ if (line[0] == '#' || line[0] == '\n')
+ continue;
+ add_test (line, filename, lineno);
+ }
+ if (ferror (fp))
+ error (EXIT_FAILURE, errno, "read from '%s'", filename);
+ if (fclose (fp) != 0)
+ error (EXIT_FAILURE, errno, "close '%s'", filename);
+}
+
+/* Calculate the generic results (round-to-zero with sticky bit) for
+ the function described by CALC, with inputs INPUTS. */
+
+static void
+calc_generic_results (generic_value *outputs, generic_value *inputs,
+ const func_calc_desc *calc)
+{
+ bool inexact;
+ switch (calc->method)
+ {
+ case mpfr_f_f:
+ assert (inputs[0].type == gtype_fp);
+ outputs[0].type = gtype_fp;
+ mpfr_init (outputs[0].value.f);
+ inexact = calc->func.mpfr_f_f (outputs[0].value.f, inputs[0].value.f,
+ MPFR_RNDZ);
+ adjust_real (outputs[0].value.f, inexact);
+ break;
+
+ default:
+ abort ();
+ }
+}
+
+/* Return the number of bits for integer type TYPE, where "long" has
+ LONG_BITS bits (32 or 64). */
+
+static int
+int_type_bits (arg_ret_type type, int long_bits)
+{
+ assert (long_bits == 32 || long_bits == 64);
+ switch (type)
+ {
+ case type_int:
+ return 32;
+ break;
+
+ case type_long:
+ return long_bits;
+ break;
+
+ case type_long_long:
+ return 64;
+ break;
+
+ default:
+ abort ();
+ }
+}
+
+/* Check whether an integer Z fits a given type TYPE, where "long" has
+ LONG_BITS bits (32 or 64). */
+
+static bool
+int_fits_type (mpz_t z, arg_ret_type type, int long_bits)
+{
+ int bits = int_type_bits (type, long_bits);
+ bool ret = true;
+ mpz_t t;
+ mpz_init (t);
+ mpz_ui_pow_ui (t, 2, bits - 1);
+ if (mpz_cmp (z, t) >= 0)
+ ret = false;
+ mpz_neg (t, t);
+ if (mpz_cmp (z, t) < 0)
+ ret = false;
+ mpz_clear (t);
+ return ret;
+}
+
+/* Print a generic value V to FP (name FILENAME), preceded by a space,
+ for type TYPE, floating-point format FORMAT, LONG_BITS bits per
+ long, printing " IGNORE" instead if IGNORE. */
+
+static void
+output_generic_value (FILE *fp, const char *filename, const generic_value *v,
+ bool ignore, arg_ret_type type, fp_format format,
+ int long_bits)
+{
+ if (ignore)
+ {
+ if (fputs (" IGNORE", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ return;
+ }
+ assert (v->type == generic_arg_ret_type (type));
+ const char *suffix;
+ switch (type)
+ {
+ case type_fp:
+ suffix = fp_formats[format].suffix;
+ break;
+
+ case type_int:
+ suffix = "";
+ break;
+
+ case type_long:
+ suffix = "L";
+ break;
+
+ case type_long_long:
+ suffix = "LL";
+ break;
+
+ default:
+ abort ();
+ }
+ switch (v->type)
+ {
+ case gtype_fp:
+ if (mpfr_inf_p (v->value.f))
+ {
+ if (fputs ((mpfr_signbit (v->value.f)
+ ? " minus_infty" : " plus_infty"), fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ }
+ else
+ {
+ assert (mpfr_number_p (v->value.f));
+ if (mpfr_fprintf (fp, " %Ra%s", v->value.f, suffix) < 0)
+ error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
+ }
+ break;
+
+ case gtype_int: ;
+ int bits = int_type_bits (type, long_bits);
+ mpz_t tmp;
+ mpz_init (tmp);
+ mpz_ui_pow_ui (tmp, 2, bits - 1);
+ mpz_neg (tmp, tmp);
+ if (mpz_cmp (v->value.i, tmp) == 0)
+ {
+ mpz_add_ui (tmp, tmp, 1);
+ if (mpfr_fprintf (fp, " (%Zd%s-1)", tmp, suffix) < 0)
+ error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
+ }
+ else
+ {
+ if (mpfr_fprintf (fp, " %Zd%s", v->value.i, suffix) < 0)
+ error (EXIT_FAILURE, errno, "mpfr_fprintf to '%s'", filename);
+ }
+ mpz_clear (tmp);
+ break;
+
+ default:
+ abort ();
+ }
+}
+
+/* Generate test output to FP (name FILENAME) for test function TF,
+ input test IT, choice of input values INPUTS. */
+
+static void
+output_for_one_input_case (FILE *fp, const char *filename, test_function *tf,
+ input_test *it, generic_value *inputs)
+{
+ bool long_bits_matters = false;
+ bool fits_long32 = true;
+ for (size_t i = 0; i < tf->num_args; i++)
+ {
+ generic_value_type gtype = generic_arg_ret_type (tf->arg_types[i]);
+ assert (inputs[i].type == gtype);
+ if (gtype == gtype_int)
+ {
+ bool fits_64 = int_fits_type (inputs[i].value.i, tf->arg_types[i],
+ 64);
+ if (!fits_64)
+ return;
+ if (tf->arg_types[i] == type_long
+ && !int_fits_type (inputs[i].value.i, tf->arg_types[i], 32))
+ {
+ long_bits_matters = true;
+ fits_long32 = false;
+ }
+ }
+ }
+ generic_value generic_outputs[MAX_NRET];
+ calc_generic_results (generic_outputs, inputs, &tf->calc);
+ bool ignore_output_long32[MAX_NRET] = { false };
+ bool ignore_output_long64[MAX_NRET] = { false };
+ for (size_t i = 0; i < tf->num_ret; i++)
+ {
+ assert (generic_outputs[i].type
+ == generic_arg_ret_type (tf->ret_types[i]));
+ switch (generic_outputs[i].type)
+ {
+ case gtype_fp:
+ if (!mpfr_number_p (generic_outputs[i].value.f))
+ goto out; /* Result is NaN or exact infinity. */
+ break;
+
+ case gtype_int:
+ ignore_output_long32[i] = !int_fits_type (generic_outputs[i].value.i,
+ tf->ret_types[i], 32);
+ ignore_output_long64[i] = !int_fits_type (generic_outputs[i].value.i,
+ tf->ret_types[i], 64);
+ if (ignore_output_long32[i] != ignore_output_long64[i])
+ long_bits_matters = true;
+ break;
+
+ default:
+ abort ();
+ }
+ }
+ /* Iterate over relevant sizes of long and floating-point formats. */
+ for (int long_bits = 32; long_bits <= 64; long_bits += 32)
+ {
+ if (long_bits == 32 && !fits_long32)
+ continue;
+ if (long_bits == 64 && !long_bits_matters)
+ continue;
+ const char *long_cond;
+ if (long_bits_matters)
+ long_cond = (long_bits == 32 ? ":long32" : ":long64");
+ else
+ long_cond = "";
+ bool *ignore_output = (long_bits == 32
+ ? ignore_output_long32
+ : ignore_output_long64);
+ for (fp_format f = fp_first_format; f < fp_num_formats; f++)
+ {
+ bool fits = true;
+ mpfr_t res[rm_num_modes];
+ unsigned int exc_before[rm_num_modes];
+ unsigned int exc_after[rm_num_modes];
+ for (size_t i = 0; i < tf->num_args; i++)
+ {
+ if (inputs[i].type == gtype_fp)
+ round_real (res, exc_before, exc_after, inputs[i].value.f, f);
+ if (!mpfr_equal_p (res[rm_tonearest], inputs[i].value.f))
+ fits = false;
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ mpfr_clear (res[m]);
+ if (!fits)
+ break;
+ }
+ if (!fits)
+ continue;
+ /* The inputs fit this type, so compute the ideal outputs
+ and exceptions. */
+ mpfr_t all_res[MAX_NRET][rm_num_modes];
+ unsigned int all_exc_before[MAX_NRET][rm_num_modes];
+ unsigned int all_exc_after[MAX_NRET][rm_num_modes];
+ unsigned int merged_exc_before[rm_num_modes] = { 0 };
+ unsigned int merged_exc_after[rm_num_modes] = { 0 };
+ /* For functions not exactly determined, track whether
+ underflow is required (some result is inexact, and
+ magnitude does not exceed the greatest magnitude
+ subnormal), and permitted (not an exact zero, and
+ magnitude does not exceed the least magnitude
+ normal). */
+ bool must_underflow = false;
+ bool may_underflow = false;
+ for (size_t i = 0; i < tf->num_ret; i++)
+ {
+ switch (generic_outputs[i].type)
+ {
+ case gtype_fp:
+ round_real (all_res[i], all_exc_before[i], all_exc_after[i],
+ generic_outputs[i].value.f, f);
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ {
+ merged_exc_before[m] |= all_exc_before[i][m];
+ merged_exc_after[m] |= all_exc_after[i][m];
+ if (!tf->exact)
+ {
+ must_underflow
+ |= ((all_exc_before[i][m]
+ & (1U << exc_inexact)) != 0
+ && (mpfr_cmpabs (generic_outputs[i].value.f,
+ fp_formats[f].subnorm_max)
+ <= 0));
+ may_underflow
+ |= (!mpfr_zero_p (generic_outputs[i].value.f)
+ && mpfr_cmpabs (generic_outputs[i].value.f,
+ fp_formats[f].min) <= 0);
+ }
+ }
+ break;
+
+ case gtype_int:
+ if (ignore_output[i])
+ for (rounding_mode m = rm_first_mode;
+ m < rm_num_modes;
+ m++)
+ {
+ merged_exc_before[m] |= 1U << exc_invalid;
+ merged_exc_after[m] |= 1U << exc_invalid;
+ }
+ break;
+
+ default:
+ abort ();
+ }
+ }
+ assert (may_underflow || !must_underflow);
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ {
+ bool before_after_matters
+ = tf->exact && merged_exc_before[m] != merged_exc_after[m];
+ for (int after = 0; after <= 1; after++)
+ {
+ if (after == 1 && !before_after_matters)
+ continue;
+ const char *after_cond;
+ if (before_after_matters)
+ after_cond = (after
+ ? ":after-rounding"
+ : ":before-rounding");
+ else
+ after_cond = "";
+ unsigned int merged_exc = (after
+ ? merged_exc_after[m]
+ : merged_exc_before[m]);
+ if (fprintf (fp, "= %s %s %s%s%s", tf->name,
+ rounding_modes[m].name, fp_formats[f].name,
+ long_cond, after_cond) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ /* Print inputs. */
+ for (size_t i = 0; i < tf->num_args; i++)
+ output_generic_value (fp, filename, &inputs[i], false,
+ tf->arg_types[i], f, long_bits);
+ if (fputs (" :", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ /* Print outputs. */
+ bool must_erange = false;
+ for (size_t i = 0; i < tf->num_ret; i++)
+ {
+ generic_value g;
+ g.type = generic_outputs[i].type;
+ switch (g.type)
+ {
+ case gtype_fp:
+ if (mpfr_inf_p (all_res[i][m])
+ && (all_exc_before[i][m]
+ & (1U << exc_overflow)) != 0)
+ must_erange = true;
+ if (mpfr_zero_p (all_res[i][m])
+ && (all_exc_before[i][m]
+ & (1U << exc_underflow)) != 0)
+ must_erange = true;
+ mpfr_init2 (g.value.f, fp_formats[f].mant_dig);
+ assert_exact (mpfr_set (g.value.f, all_res[i][m],
+ MPFR_RNDN));
+ break;
+
+ case gtype_int:
+ mpz_init (g.value.i);
+ mpz_set (g.value.i, generic_outputs[i].value.i);
+ break;
+
+ default:
+ abort ();
+ }
+ output_generic_value (fp, filename, &g, ignore_output[i],
+ tf->ret_types[i], f, long_bits);
+ generic_value_free (&g);
+ }
+ if (fputs (" :", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ /* Print miscellaneous flags (passed through from
+ input). */
+ for (size_t i = 0; i < it->num_flags; i++)
+ switch (it->flags[i].type)
+ {
+ case flag_no_test_inline:
+ case flag_xfail:
+ if (fprintf (fp, " %s%s",
+ input_flags[it->flags[i].type],
+ (it->flags[i].cond
+ ? it->flags[i].cond
+ : "")) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ break;
+ default:
+ break;
+ }
+ /* Print exception flags and compute errno
+ expectations where not already computed. */
+ bool may_edom = false;
+ bool must_edom = false;
+ bool may_erange = must_erange || may_underflow;
+ for (fp_exception e = exc_first_exception;
+ e < exc_num_exceptions;
+ e++)
+ {
+ bool expect_e = (merged_exc & (1U << e)) != 0;
+ bool e_optional = false;
+ switch (e)
+ {
+ case exc_divbyzero:
+ if (expect_e)
+ may_erange = must_erange = true;
+ break;
+
+ case exc_inexact:
+ if (!tf->exact)
+ e_optional = true;
+ break;
+
+ case exc_invalid:
+ if (expect_e)
+ may_edom = must_edom = true;
+ break;
+
+ case exc_overflow:
+ if (expect_e)
+ may_erange = true;
+ break;
+
+ case exc_underflow:
+ if (expect_e)
+ may_erange = true;
+ if (must_underflow)
+ assert (expect_e);
+ if (may_underflow && !must_underflow)
+ e_optional = true;
+ break;
+
+ default:
+ abort ();
+ }
+ if (e_optional)
+ {
+ if (fprintf (fp, " %s-ok", exceptions[e]) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ else
+ {
+ if (expect_e)
+ if (fprintf (fp, " %s", exceptions[e]) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ input_flag_type okflag;
+ okflag = (expect_e
+ ? flag_missing_first
+ : flag_spurious_first) + e;
+ for (size_t i = 0; i < it->num_flags; i++)
+ if (it->flags[i].type == okflag)
+ if (fprintf (fp, " %s-ok%s",
+ exceptions[e],
+ (it->flags[i].cond
+ ? it->flags[i].cond
+ : "")) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ }
+ /* Print errno expectations. */
+ if (tf->complex_fn)
+ {
+ must_edom = false;
+ must_erange = false;
+ }
+ if (may_edom && !must_edom)
+ {
+ if (fputs (" errno-edom-ok", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ else
+ {
+ if (must_edom)
+ if (fputs (" errno-edom", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ input_flag_type okflag = (must_edom
+ ? flag_missing_errno
+ : flag_spurious_errno);
+ for (size_t i = 0; i < it->num_flags; i++)
+ if (it->flags[i].type == okflag)
+ if (fprintf (fp, " errno-edom-ok%s",
+ (it->flags[i].cond
+ ? it->flags[i].cond
+ : "")) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ if (may_erange && !must_erange)
+ {
+ if (fputs (" errno-erange-ok", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ else
+ {
+ if (must_erange)
+ if (fputs (" errno-erange", fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ input_flag_type okflag = (must_erange
+ ? flag_missing_errno
+ : flag_spurious_errno);
+ for (size_t i = 0; i < it->num_flags; i++)
+ if (it->flags[i].type == okflag)
+ if (fprintf (fp, " errno-erange-ok%s",
+ (it->flags[i].cond
+ ? it->flags[i].cond
+ : "")) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'",
+ filename);
+ }
+ if (putc ('\n', fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ }
+ }
+ for (size_t i = 0; i < tf->num_ret; i++)
+ {
+ if (generic_outputs[i].type == gtype_fp)
+ for (rounding_mode m = rm_first_mode; m < rm_num_modes; m++)
+ mpfr_clear (all_res[i][m]);
+ }
+ }
+ }
+ out:
+ for (size_t i = 0; i < tf->num_ret; i++)
+ generic_value_free (&generic_outputs[i]);
+}
+
+/* Generate test output data to FILENAME. */
+
+static void
+generate_output (const char *filename)
+{
+ FILE *fp = fopen (filename, "w");
+ if (fp == NULL)
+ error (EXIT_FAILURE, errno, "open '%s'", filename);
+ for (size_t i = 0; i < ARRAY_SIZE (test_functions); i++)
+ {
+ test_function *tf = &test_functions[i];
+ for (size_t j = 0; j < tf->num_tests; j++)
+ {
+ input_test *it = &tf->tests[j];
+ if (fputs (it->line, fp) < 0)
+ error (EXIT_FAILURE, errno, "write to '%s'", filename);
+ for (size_t k = 0; k < it->num_input_cases; k++)
+ output_for_one_input_case (fp, filename, tf, it, it->inputs[k]);
+ }
+ }
+ if (fclose (fp) != 0)
+ error (EXIT_FAILURE, errno, "close '%s'", filename);
+}
+
+int
+main (int argc, char **argv)
+{
+ if (argc != 3)
+ error (EXIT_FAILURE, 0, "usage: gen-auto-libm-tests <input> <output>");
+ const char *input_filename = argv[1];
+ const char *output_filename = argv[2];
+ init_fp_formats ();
+ read_input (input_filename);
+ generate_output (output_filename);
+ exit (EXIT_SUCCESS);
+}
projects / platform / upstream / linaro-glibc.git / commitdiff