1 /* Generate table of tests in tst-strtod-round.c from
2 tst-strtod-round-data.
3 Copyright (C) 2012-2023 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20 /* Compile this program as:
21
22 gcc -std=gnu11 -O2 -Wall -Wextra gen-tst-strtod-round.c -lmpfr \
23 -o gen-tst-strtod-round
24
25 (use of current MPFR version recommended) and run it as:
26
27 gen-tst-strtod-round tst-strtod-round-data tst-strtod-round-data.h
28
29 The output file will be generated as tst-strtod-round-data.h
30 */
31
32
33 #define _GNU_SOURCE
34 #include <assert.h>
35 #include <stdbool.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <mpfr.h>
40
41 /* Work around incorrect ternary value from mpfr_strtofr
42 <https://sympa.inria.fr/sympa/arc/mpfr/2012-08/msg00005.html>. */
43 #define WORKAROUND
44
45 static int
46 string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd)
47 {
48 mpfr_clear_overflow ();
49 #ifdef WORKAROUND
50 mpfr_t f2;
51 mpfr_init2 (f2, 100000);
52 int r0 = mpfr_strtofr (f2, s, NULL, 0, rnd);
53 int r = mpfr_set (f, f2, rnd);
54 r |= mpfr_subnormalize (f, r, rnd);
55 mpfr_clear (f2);
56 return r0 | r;
57 #else
58 int r = mpfr_strtofr (f, s, NULL, 0, rnd);
59 r |= mpfr_subnormalize (f, r, rnd);
60 return r;
61 #endif
62 }
63
64 void
65 print_fp (FILE *fout, mpfr_t f, const char *suffix)
66 {
67 if (mpfr_inf_p (f))
68 mpfr_fprintf (fout, "\t%sINF%s", mpfr_signbit (f) ? "-" : "", suffix);
69 else
70 mpfr_fprintf (fout, "\t%Ra%s", f, suffix);
71 }
72
73 static void
74 round_str (FILE *fout, const char *s, int prec, int emin, int emax,
75 bool ibm_ld)
76 {
77 mpfr_t max_value;
78 mpfr_t f;
79 mpfr_set_default_prec (prec);
80 mpfr_set_emin (emin);
81 mpfr_set_emax (emax);
82 mpfr_init (f);
83 int r = string_to_fp (f, s, MPFR_RNDD);
84 bool overflow = mpfr_overflow_p () != 0;
85 if (ibm_ld)
86 {
87 assert (prec == 106 && emin == -1073 && emax == 1024);
88 /* The maximum value in IBM long double has discontiguous
89 mantissa bits. */
90 mpfr_init2 (max_value, 107);
91 mpfr_set_str (max_value, "0x1.fffffffffffff7ffffffffffffcp+1023", 0,
92 MPFR_RNDN);
93 if (mpfr_cmpabs (f, max_value) > 0)
94 {
95 r = 1;
96 overflow = true;
97 }
98 }
99 mpfr_fprintf (fout, "\t%s,\n", r ? "false" : "true");
100 print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
101 string_to_fp (f, s, MPFR_RNDN);
102 overflow = (mpfr_overflow_p () != 0
103 || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
104 print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
105 string_to_fp (f, s, MPFR_RNDZ);
106 overflow = (mpfr_overflow_p () != 0
107 || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
108 print_fp (fout, f, overflow ? ", true,\n" : ", false,\n");
109 string_to_fp (f, s, MPFR_RNDU);
110 overflow = (mpfr_overflow_p () != 0
111 || (ibm_ld && mpfr_cmpabs (f, max_value) > 0));
112 print_fp (fout, f, overflow ? ", true" : ", false");
113 mpfr_clear (f);
114 if (ibm_ld)
115 mpfr_clear (max_value);
116 }
117
118 static void
119 round_for_all (FILE *fout, const char *s)
120 {
121 static const struct fmt {
122 int prec;
123 int emin;
124 int emax;
125 bool ibm_ld;
126 } formats[] = {
127 { 24, -148, 128, false },
128 { 53, -1073, 1024, false },
129 /* This is the Intel extended float format. */
130 { 64, -16444, 16384, false },
131 /* This is the Motorola extended float format. */
132 { 64, -16445, 16384, false },
133 { 106, -1073, 1024, true },
134 { 113, -16493, 16384, false },
135 };
136 mpfr_fprintf (fout, " TEST (\"");
137 const char *p;
138 for (p = s; *p; p++)
139 {
140 fputc (*p, fout);
141 if ((p - s) % 60 == 59 && p[1])
142 mpfr_fprintf (fout, "\"\n\t\"");
143 }
144 mpfr_fprintf (fout, "\",\n");
145 int i;
146 int n_formats = sizeof (formats) / sizeof (formats[0]);
147 for (i = 0; i < n_formats; i++)
148 {
149 round_str (fout, s, formats[i].prec, formats[i].emin,
150 formats[i].emax, formats[i].ibm_ld);
151 if (i < n_formats - 1)
152 mpfr_fprintf (fout, ",\n");
153 }
154 mpfr_fprintf (fout, "),\n");
155 }
156
157 int
158 main (int argc, char **argv)
159 {
160 char *p = NULL;
161 size_t len;
162 ssize_t nbytes;
163 FILE *fin, *fout;
164 char *fin_name, *fout_name;
165
166 if (argc < 3)
167 {
168 fprintf (stderr, "Usage: %s <input> <output>\n", basename (argv[0]));
169 return EXIT_FAILURE;
170 }
171
172 fin_name = argv[1];
173 fout_name = argv[2];
174
175 fin = fopen (fin_name, "r");
176 if (fin == NULL)
177 {
178 perror ("Could not open input for reading");
179 return EXIT_FAILURE;
180 }
181
182 fout = fopen (fout_name, "w");
183 if (fout == NULL)
184 {
185 perror ("Could not open output for writing");
186 return EXIT_FAILURE;
187 }
188
189 fprintf (fout, "/* This file was generated by %s from %s. */\n",
190 __FILE__, fin_name);
191 fputs ("static const struct test tests[] = {\n", fout);
192 while ((nbytes = getline (&p, &len, fin)) != -1)
193 {
194 if (p[nbytes - 1] == '\n')
195 p[nbytes - 1] = 0;
196 round_for_all (fout, p);
197 free (p);
198 p = NULL;
199 }
200 fputs ("};\n", fout);
201
202 return EXIT_SUCCESS;
203 }