Bug Summary

File:src/lib/libc/gdtoa/gdtoa.c
Warning:line 742, column 6
Value stored to 'inex' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name gdtoa.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libc/obj -resource-dir /usr/local/lib/clang/13.0.0 -include namespace.h -I /usr/src/lib/libc/include -I /usr/src/lib/libc/hidden -D __LIBC__ -D APIWARN -D YP -I /usr/src/lib/libc/yp -I /usr/src/lib/libc -I /usr/src/lib/libc/gdtoa -I /usr/src/lib/libc/arch/amd64/gdtoa -D INFNAN_CHECK -D MULTIPLE_THREADS -D NO_FENV_H -D USE_LOCALE -I /usr/src/lib/libc -I /usr/src/lib/libc/citrus -D RESOLVSORT -D FLOATING_POINT -D PRINTF_WIDE_CHAR -D SCANF_WIDE_CHAR -D FUTEX -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libc/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libc/gdtoa/gdtoa.c
1/****************************************************************
2
3The author of this software is David M. Gay.
4
5Copyright (C) 1998, 1999 by Lucent Technologies
6All Rights Reserved
7
8Permission to use, copy, modify, and distribute this software and
9its documentation for any purpose and without fee is hereby
10granted, provided that the above copyright notice appear in all
11copies and that both that the copyright notice and this
12permission notice and warranty disclaimer appear in supporting
13documentation, and that the name of Lucent or any of its entities
14not be used in advertising or publicity pertaining to
15distribution of the software without specific, written prior
16permission.
17
18LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
19INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
20IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
21SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
23IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
25THIS SOFTWARE.
26
27****************************************************************/
28
29/* Please send bug reports to David M. Gay (dmg at acm dot org,
30 * with " at " changed at "@" and " dot " changed to "."). */
31
32#include "gdtoaimp.h"
33
34 static Bigint *
35#ifdef KR_headers
36bitstob(bits, nbits, bbits) ULong *bits; int nbits; int *bbits;
37#else
38bitstob(ULong *bits, int nbits, int *bbits)
39#endif
40{
41 int i, k;
42 Bigint *b;
43 ULong *be, *x, *x0;
44
45 i = ULbits32;
46 k = 0;
47 while(i < nbits) {
48 i <<= 1;
49 k++;
50 }
51#ifndef Pack_32
52 if (!k)
53 k = 1;
54#endif
55 b = Balloc__Balloc_D2A(k);
56 if (b == NULL((void*)0))
57 return (NULL((void*)0));
58 be = bits + ((nbits - 1) >> kshift5);
59 x = x0 = b->x;
60 do {
61 *x++ = *bits & ALL_ON0xffffffff;
62#ifdef Pack_16
63 *x++ = (*bits >> 16) & ALL_ON0xffffffff;
64#endif
65 } while(++bits <= be);
66 i = x - x0;
67 while(!x0[--i])
68 if (!i) {
69 b->wds = 0;
70 *bbits = 0;
71 goto ret;
72 }
73 b->wds = i + 1;
74 *bbits = i*ULbits32 + 32 - hi0bits(b->x[i])__hi0bits_D2A((ULong)(b->x[i]));
75 ret:
76 return b;
77 }
78
79/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
80 *
81 * Inspired by "How to Print Floating-Point Numbers Accurately" by
82 * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
83 *
84 * Modifications:
85 * 1. Rather than iterating, we use a simple numeric overestimate
86 * to determine k = floor(log10(d)). We scale relevant
87 * quantities using O(log2(k)) rather than O(k) multiplications.
88 * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
89 * try to generate digits strictly left to right. Instead, we
90 * compute with fewer bits and propagate the carry if necessary
91 * when rounding the final digit up. This is often faster.
92 * 3. Under the assumption that input will be rounded nearest,
93 * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
94 * That is, we allow equality in stopping tests when the
95 * round-nearest rule will give the same floating-point value
96 * as would satisfaction of the stopping test with strict
97 * inequality.
98 * 4. We remove common factors of powers of 2 from relevant
99 * quantities.
100 * 5. When converting floating-point integers less than 1e16,
101 * we use floating-point arithmetic rather than resorting
102 * to multiple-precision integers.
103 * 6. When asked to produce fewer than 15 digits, we first try
104 * to get by with floating-point arithmetic; we resort to
105 * multiple-precision integer arithmetic only if we cannot
106 * guarantee that the floating-point calculation has given
107 * the correctly rounded result. For k requested digits and
108 * "uniformly" distributed input, the probability is
109 * something like 10^(k-15) that we must resort to the Long
110 * calculation.
111 */
112
113 char *
114gdtoa__gdtoa
115#ifdef KR_headers
116 (fpi, be, bits, kindp, mode, ndigits, decpt, rve)
117 FPI *fpi; int be; ULong *bits;
118 int *kindp, mode, ndigits, *decpt; char **rve;
119#else
120 (FPI *fpi, int be, ULong *bits, int *kindp, int mode, int ndigits, int *decpt, char **rve)
121#endif
122{
123 /* Arguments ndigits and decpt are similar to the second and third
124 arguments of ecvt and fcvt; trailing zeros are suppressed from
125 the returned string. If not null, *rve is set to point
126 to the end of the return value. If d is +-Infinity or NaN,
127 then *decpt is set to 9999.
128 be = exponent: value = (integer represented by bits) * (2 to the power of be).
129
130 mode:
131 0 ==> shortest string that yields d when read in
132 and rounded to nearest.
133 1 ==> like 0, but with Steele & White stopping rule;
134 e.g. with IEEE P754 arithmetic , mode 0 gives
135 1e23 whereas mode 1 gives 9.999999999999999e22.
136 2 ==> max(1,ndigits) significant digits. This gives a
137 return value similar to that of ecvt, except
138 that trailing zeros are suppressed.
139 3 ==> through ndigits past the decimal point. This
140 gives a return value similar to that from fcvt,
141 except that trailing zeros are suppressed, and
142 ndigits can be negative.
143 4-9 should give the same return values as 2-3, i.e.,
144 4 <= mode <= 9 ==> same return as mode
145 2 + (mode & 1). These modes are mainly for
146 debugging; often they run slower but sometimes
147 faster than modes 2-3.
148 4,5,8,9 ==> left-to-right digit generation.
149 6-9 ==> don't try fast floating-point estimate
150 (if applicable).
151
152 Values of mode other than 0-9 are treated as mode 0.
153
154 Sufficient space is allocated to the return value
155 to hold the suppressed trailing zeros.
156 */
157
158 int bbits, b2, b5, be0, dig, i, ieps, ilim, ilim0, ilim1, inex;
159 int j, j1, k, k0, k_check, kind, leftright, m2, m5, nbits;
160 int rdir, s2, s5, spec_case, try_quick;
161 Longint L;
162 Bigint *b, *b1, *delta, *mlo, *mhi, *mhi1, *S;
163 double d2, ds;
164 char *s, *s0;
165 U d, eps;
166
167#ifndef MULTIPLE_THREADS1
168 if (dtoa_result__dtoa_result_D2A) {
169 freedtoa__freedtoa(dtoa_result__dtoa_result_D2A);
170 dtoa_result__dtoa_result_D2A = 0;
171 }
172#endif
173 inex = 0;
174 kind = *kindp &= ~STRTOG_Inexact;
175 switch(kind & STRTOG_Retmask) {
176 case STRTOG_Zero:
177 goto ret_zero;
178 case STRTOG_Normal:
179 case STRTOG_Denormal:
180 break;
181 case STRTOG_Infinite:
182 *decpt = -32768;
183 return nrv_alloc__nrv_alloc_D2A("Infinity", rve, 8);
184 case STRTOG_NaN:
185 *decpt = -32768;
186 return nrv_alloc__nrv_alloc_D2A("NaN", rve, 3);
187 default:
188 return 0;
189 }
190 b = bitstob(bits, nbits = fpi->nbits, &bbits);
191 if (b == NULL((void*)0))
192 return (NULL((void*)0));
193 be0 = be;
194 if ( (i = trailz__trailz_D2A(b)) !=0) {
195 rshift__rshift_D2A(b, i);
196 be += i;
197 bbits -= i;
198 }
199 if (!b->wds) {
200 Bfree__Bfree_D2A(b);
201 ret_zero:
202 *decpt = 1;
203 return nrv_alloc__nrv_alloc_D2A("0", rve, 1);
204 }
205
206 dval(&d)(&d)->d = b2d__b2d_D2A(b, &i);
207 i = be + bbits - 1;
208 word0(&d)(&d)->L[1] &= Frac_mask10xfffff;
209 word0(&d)(&d)->L[1] |= Exp_110x3ff00000;
210#ifdef IBM
211 if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)__hi0bits_D2A((ULong)((&d)->L[1] & 0xfffff))) !=0)
212 dval(&d)(&d)->d /= 1 << j;
213#endif
214
215 /* log(x) ~=~ log(1.5) + (x-1.5)/1.5
216 * log10(x) = log(x) / log(10)
217 * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
218 * log10(&d) = (i-Bias)*log(2)/log(10) + log10(d2)
219 *
220 * This suggests computing an approximation k to log10(&d) by
221 *
222 * k = (i - Bias)*0.301029995663981
223 * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
224 *
225 * We want k to be too large rather than too small.
226 * The error in the first-order Taylor series approximation
227 * is in our favor, so we just round up the constant enough
228 * to compensate for any error in the multiplication of
229 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
230 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
231 * adding 1e-13 to the constant term more than suffices.
232 * Hence we adjust the constant term to 0.1760912590558.
233 * (We could get a more accurate k by invoking log10,
234 * but this is probably not worthwhile.)
235 */
236#ifdef IBM
237 i <<= 2;
238 i += j;
239#endif
240 ds = (dval(&d)(&d)->d-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
241
242 /* correct assumption about exponent range */
243 if ((j = i) < 0)
244 j = -j;
245 if ((j -= 1077) > 0)
246 ds += j * 7e-17;
247
248 k = (int)ds;
249 if (ds < 0. && ds != k)
250 k--; /* want k = floor(ds) */
251 k_check = 1;
252#ifdef IBM
253 j = be + bbits - 1;
254 if ( (j1 = j & 3) !=0)
255 dval(&d)(&d)->d *= 1 << j1;
256 word0(&d)(&d)->L[1] += j << Exp_shift20 - 2 & Exp_mask0x7ff00000;
257#else
258 word0(&d)(&d)->L[1] += (be + bbits - 1) << Exp_shift20;
259#endif
260 if (k >= 0 && k <= Ten_pmax22) {
261 if (dval(&d)(&d)->d < tens__tens_D2A[k])
262 k--;
263 k_check = 0;
264 }
265 j = bbits - i - 1;
266 if (j >= 0) {
267 b2 = 0;
268 s2 = j;
269 }
270 else {
271 b2 = -j;
272 s2 = 0;
273 }
274 if (k >= 0) {
275 b5 = 0;
276 s5 = k;
277 s2 += k;
278 }
279 else {
280 b2 -= k;
281 b5 = -k;
282 s5 = 0;
283 }
284 if (mode < 0 || mode > 9)
285 mode = 0;
286 try_quick = 1;
287 if (mode > 5) {
288 mode -= 4;
289 try_quick = 0;
290 }
291 else if (i >= -4 - Emin(-1022) || i < Emin(-1022))
292 try_quick = 0;
293 leftright = 1;
294 ilim = ilim1 = -1; /* Values for cases 0 and 1; done here to */
295 /* silence erroneous "gcc -Wall" warning. */
296 switch(mode) {
297 case 0:
298 case 1:
299 i = (int)(nbits * .30103) + 3;
300 ndigits = 0;
301 break;
302 case 2:
303 leftright = 0;
304 /* no break */
305 case 4:
306 if (ndigits <= 0)
307 ndigits = 1;
308 ilim = ilim1 = i = ndigits;
309 break;
310 case 3:
311 leftright = 0;
312 /* no break */
313 case 5:
314 i = ndigits + k + 1;
315 ilim = i;
316 ilim1 = i - 1;
317 if (i <= 0)
318 i = 1;
319 }
320 s = s0 = rv_alloc__rv_alloc_D2A(i);
321 if (s == NULL((void*)0))
322 return (NULL((void*)0));
323
324 if ( (rdir = fpi->rounding - 1) !=0) {
325 if (rdir < 0)
326 rdir = 2;
327 if (kind & STRTOG_Neg)
328 rdir = 3 - rdir;
329 }
330
331 /* Now rdir = 0 ==> round near, 1 ==> round up, 2 ==> round down. */
332
333 if (ilim >= 0 && ilim <= Quick_max14 && try_quick && !rdir
334#ifndef IMPRECISE_INEXACT
335 && k == 0
336#endif
337 ) {
338
339 /* Try to get by with floating-point arithmetic. */
340
341 i = 0;
342 d2 = dval(&d)(&d)->d;
343#ifdef IBM
344 if ( (j = 11 - hi0bits(word0(&d) & Frac_mask)__hi0bits_D2A((ULong)((&d)->L[1] & 0xfffff))) !=0)
345 dval(&d)(&d)->d /= 1 << j;
346#endif
347 k0 = k;
348 ilim0 = ilim;
349 ieps = 2; /* conservative */
350 if (k > 0) {
351 ds = tens__tens_D2A[k&0xf];
352 j = k >> 4;
353 if (j & Bletch0x10) {
354 /* prevent overflows */
355 j &= Bletch0x10 - 1;
356 dval(&d)(&d)->d /= bigtens__bigtens_D2A[n_bigtens5-1];
357 ieps++;
358 }
359 for(; j; j >>= 1, i++)
360 if (j & 1) {
361 ieps++;
362 ds *= bigtens__bigtens_D2A[i];
363 }
364 }
365 else {
366 ds = 1.;
367 if ( (j1 = -k) !=0) {
368 dval(&d)(&d)->d *= tens__tens_D2A[j1 & 0xf];
369 for(j = j1 >> 4; j; j >>= 1, i++)
370 if (j & 1) {
371 ieps++;
372 dval(&d)(&d)->d *= bigtens__bigtens_D2A[i];
373 }
374 }
375 }
376 if (k_check && dval(&d)(&d)->d < 1. && ilim > 0) {
377 if (ilim1 <= 0)
378 goto fast_failed;
379 ilim = ilim1;
380 k--;
381 dval(&d)(&d)->d *= 10.;
382 ieps++;
383 }
384 dval(&eps)(&eps)->d = ieps*dval(&d)(&d)->d + 7.;
385 word0(&eps)(&eps)->L[1] -= (P53-1)*Exp_msk10x100000;
386 if (ilim == 0) {
387 S = mhi = 0;
388 dval(&d)(&d)->d -= 5.;
389 if (dval(&d)(&d)->d > dval(&eps)(&eps)->d)
390 goto one_digit;
391 if (dval(&d)(&d)->d < -dval(&eps)(&eps)->d)
392 goto no_digits;
393 goto fast_failed;
394 }
395#ifndef No_leftright
396 if (leftright) {
397 /* Use Steele & White method of only
398 * generating digits needed.
399 */
400 dval(&eps)(&eps)->d = ds*0.5/tens__tens_D2A[ilim-1] - dval(&eps)(&eps)->d;
401 for(i = 0;;) {
402 L = (Longint)(dval(&d)(&d)->d/ds);
403 dval(&d)(&d)->d -= L*ds;
404 *s++ = '0' + (int)L;
405 if (dval(&d)(&d)->d < dval(&eps)(&eps)->d) {
406 if (dval(&d)(&d)->d)
407 inex = STRTOG_Inexlo;
408 goto ret1;
409 }
410 if (ds - dval(&d)(&d)->d < dval(&eps)(&eps)->d)
411 goto bump_up;
412 if (++i >= ilim)
413 break;
414 dval(&eps)(&eps)->d *= 10.;
415 dval(&d)(&d)->d *= 10.;
416 }
417 }
418 else {
419#endif
420 /* Generate ilim digits, then fix them up. */
421 dval(&eps)(&eps)->d *= tens__tens_D2A[ilim-1];
422 for(i = 1;; i++, dval(&d)(&d)->d *= 10.) {
423 if ( (L = (Longint)(dval(&d)(&d)->d/ds)) !=0)
424 dval(&d)(&d)->d -= L*ds;
425 *s++ = '0' + (int)L;
426 if (i == ilim) {
427 ds *= 0.5;
428 if (dval(&d)(&d)->d > ds + dval(&eps)(&eps)->d)
429 goto bump_up;
430 else if (dval(&d)(&d)->d < ds - dval(&eps)(&eps)->d) {
431 if (dval(&d)(&d)->d)
432 inex = STRTOG_Inexlo;
433 goto clear_trailing0;
434 }
435 break;
436 }
437 }
438#ifndef No_leftright
439 }
440#endif
441 fast_failed:
442 s = s0;
443 dval(&d)(&d)->d = d2;
444 k = k0;
445 ilim = ilim0;
446 }
447
448 /* Do we have a "small" integer? */
449
450 if (be >= 0 && k <= Int_max14) {
451 /* Yes. */
452 ds = tens__tens_D2A[k];
453 if (ndigits < 0 && ilim <= 0) {
454 S = mhi = 0;
455 if (ilim < 0 || dval(&d)(&d)->d <= 5*ds)
456 goto no_digits;
457 goto one_digit;
458 }
459 for(i = 1;; i++, dval(&d)(&d)->d *= 10.) {
460 L = dval(&d)(&d)->d / ds;
461 dval(&d)(&d)->d -= L*ds;
462#ifdef Check_FLT_ROUNDS
463 /* If FLT_ROUNDS == 2, L will usually be high by 1 */
464 if (dval(&d)(&d)->d < 0) {
465 L--;
466 dval(&d)(&d)->d += ds;
467 }
468#endif
469 *s++ = '0' + (int)L;
470 if (dval(&d)(&d)->d == 0.)
471 break;
472 if (i == ilim) {
473 if (rdir) {
474 if (rdir == 1)
475 goto bump_up;
476 inex = STRTOG_Inexlo;
477 goto ret1;
478 }
479 dval(&d)(&d)->d += dval(&d)(&d)->d;
480#ifdef ROUND_BIASED
481 if (dval(&d)(&d)->d >= ds)
482#else
483 if (dval(&d)(&d)->d > ds || (dval(&d)(&d)->d == ds && L & 1))
484#endif
485 {
486 bump_up:
487 inex = STRTOG_Inexhi;
488 while(*--s == '9')
489 if (s == s0) {
490 k++;
491 *s = '0';
492 break;
493 }
494 ++*s++;
495 }
496 else {
497 inex = STRTOG_Inexlo;
498 clear_trailing0:
499 while(*--s == '0'){}
500 ++s;
501 }
502 break;
503 }
504 }
505 goto ret1;
506 }
507
508 m2 = b2;
509 m5 = b5;
510 mhi = mlo = 0;
511 if (leftright) {
512 i = nbits - bbits;
513 if (be - i++ < fpi->emin && mode != 3 && mode != 5) {
514 /* denormal */
515 i = be - fpi->emin + 1;
516 if (mode >= 2 && ilim > 0 && ilim < i)
517 goto small_ilim;
518 }
519 else if (mode >= 2) {
520 small_ilim:
521 j = ilim - 1;
522 if (m5 >= j)
523 m5 -= j;
524 else {
525 s5 += j -= m5;
526 b5 += j;
527 m5 = 0;
528 }
529 if ((i = ilim) < 0) {
530 m2 -= i;
531 i = 0;
532 }
533 }
534 b2 += i;
535 s2 += i;
536 mhi = i2b__i2b_D2A(1);
537 if (mhi == NULL((void*)0))
538 return (NULL((void*)0));
539 }
540 if (m2 > 0 && s2 > 0) {
541 i = m2 < s2 ? m2 : s2;
542 b2 -= i;
543 m2 -= i;
544 s2 -= i;
545 }
546 if (b5 > 0) {
547 if (leftright) {
548 if (m5 > 0) {
549 mhi = pow5mult__pow5mult_D2A(mhi, m5);
550 if (mhi == NULL((void*)0))
551 return (NULL((void*)0));
552 b1 = mult__mult_D2A(mhi, b);
553 if (b1 == NULL((void*)0))
554 return (NULL((void*)0));
555 Bfree__Bfree_D2A(b);
556 b = b1;
557 }
558 if ( (j = b5 - m5) !=0) {
559 b = pow5mult__pow5mult_D2A(b, j);
560 if (b == NULL((void*)0))
561 return (NULL((void*)0));
562 }
563 }
564 else {
565 b = pow5mult__pow5mult_D2A(b, b5);
566 if (b == NULL((void*)0))
567 return (NULL((void*)0));
568 }
569 }
570 S = i2b__i2b_D2A(1);
571 if (S == NULL((void*)0))
572 return (NULL((void*)0));
573 if (s5 > 0) {
574 S = pow5mult__pow5mult_D2A(S, s5);
575 if (S == NULL((void*)0))
576 return (NULL((void*)0));
577 }
578
579 /* Check for special case that d is a normalized power of 2. */
580
581 spec_case = 0;
582 if (mode < 2) {
583 if (bbits == 1 && be0 > fpi->emin + 1) {
584 /* The special case */
585 b2++;
586 s2++;
587 spec_case = 1;
588 }
589 }
590
591 /* Arrange for convenient computation of quotients:
592 * shift left if necessary so divisor has 4 leading 0 bits.
593 *
594 * Perhaps we should just compute leading 28 bits of S once
595 * and for all and pass them and a shift to quorem, so it
596 * can do shifts and ors to compute the numerator for q.
597 */
598 i = ((s5 ? hi0bits(S->x[S->wds-1])__hi0bits_D2A((ULong)(S->x[S->wds-1])) : ULbits32 - 1) - s2 - 4) & kmask31;
599 m2 += i;
600 if ((b2 += i) > 0) {
601 b = lshift__lshift_D2A(b, b2);
602 if (b == NULL((void*)0))
603 return (NULL((void*)0));
604 }
605 if ((s2 += i) > 0) {
606 S = lshift__lshift_D2A(S, s2);
607 if (S == NULL((void*)0))
608 return (NULL((void*)0));
609 }
610 if (k_check) {
611 if (cmp__cmp_D2A(b,S) < 0) {
612 k--;
613 b = multadd__multadd_D2A(b, 10, 0); /* we botched the k estimate */
614 if (b == NULL((void*)0))
615 return (NULL((void*)0));
616 if (leftright) {
617 mhi = multadd__multadd_D2A(mhi, 10, 0);
618 if (mhi == NULL((void*)0))
619 return (NULL((void*)0));
620 }
621 ilim = ilim1;
622 }
623 }
624 if (ilim <= 0 && mode > 2) {
625 S = multadd__multadd_D2A(S,5,0);
626 if (S == NULL((void*)0))
627 return (NULL((void*)0));
628 if (ilim < 0 || cmp__cmp_D2A(b,S) <= 0) {
629 /* no digits, fcvt style */
630 no_digits:
631 k = -1 - ndigits;
632 inex = STRTOG_Inexlo;
633 goto ret;
634 }
635 one_digit:
636 inex = STRTOG_Inexhi;
637 *s++ = '1';
638 k++;
639 goto ret;
640 }
641 if (leftright) {
642 if (m2 > 0) {
643 mhi = lshift__lshift_D2A(mhi, m2);
644 if (mhi == NULL((void*)0))
645 return (NULL((void*)0));
646 }
647
648 /* Compute mlo -- check for special case
649 * that d is a normalized power of 2.
650 */
651
652 mlo = mhi;
653 if (spec_case) {
654 mhi = Balloc__Balloc_D2A(mhi->k);
655 if (mhi == NULL((void*)0))
656 return (NULL((void*)0));
657 Bcopy(mhi, mlo)memcpy(&mhi->sign,&mlo->sign,mlo->wds*sizeof
(ULong) + 2*sizeof(int))
;
658 mhi = lshift__lshift_D2A(mhi, 1);
659 if (mhi == NULL((void*)0))
660 return (NULL((void*)0));
661 }
662
663 for(i = 1;;i++) {
664 dig = quorem__quorem_D2A(b,S) + '0';
665 /* Do we yet have the shortest decimal string
666 * that will round to d?
667 */
668 j = cmp__cmp_D2A(b, mlo);
669 delta = diff__diff_D2A(S, mhi);
670 if (delta == NULL((void*)0))
671 return (NULL((void*)0));
672 j1 = delta->sign ? 1 : cmp__cmp_D2A(b, delta);
673 Bfree__Bfree_D2A(delta);
674#ifndef ROUND_BIASED
675 if (j1 == 0 && !mode && !(bits[0] & 1) && !rdir) {
676 if (dig == '9')
677 goto round_9_up;
678 if (j <= 0) {
679 if (b->wds > 1 || b->x[0])
680 inex = STRTOG_Inexlo;
681 }
682 else {
683 dig++;
684 inex = STRTOG_Inexhi;
685 }
686 *s++ = dig;
687 goto ret;
688 }
689#endif
690 if (j < 0 || (j == 0 && !mode
691#ifndef ROUND_BIASED
692 && !(bits[0] & 1)
693#endif
694 )) {
695 if (rdir && (b->wds > 1 || b->x[0])) {
696 if (rdir == 2) {
697 inex = STRTOG_Inexlo;
698 goto accept;
699 }
700 while (cmp__cmp_D2A(S,mhi) > 0) {
701 *s++ = dig;
702 mhi1 = multadd__multadd_D2A(mhi, 10, 0);
703 if (mhi1 == NULL((void*)0))
704 return (NULL((void*)0));
705 if (mlo == mhi)
706 mlo = mhi1;
707 mhi = mhi1;
708 b = multadd__multadd_D2A(b, 10, 0);
709 if (b == NULL((void*)0))
710 return (NULL((void*)0));
711 dig = quorem__quorem_D2A(b,S) + '0';
712 }
713 if (dig++ == '9')
714 goto round_9_up;
715 inex = STRTOG_Inexhi;
716 goto accept;
717 }
718 if (j1 > 0) {
719 b = lshift__lshift_D2A(b, 1);
720 if (b == NULL((void*)0))
721 return (NULL((void*)0));
722 j1 = cmp__cmp_D2A(b, S);
723#ifdef ROUND_BIASED
724 if (j1 >= 0 /*)*/
725#else
726 if ((j1 > 0 || (j1 == 0 && dig & 1))
727#endif
728 && dig++ == '9')
729 goto round_9_up;
730 inex = STRTOG_Inexhi;
731 }
732 if (b->wds > 1 || b->x[0])
733 inex = STRTOG_Inexlo;
734 accept:
735 *s++ = dig;
736 goto ret;
737 }
738 if (j1 > 0 && rdir != 2) {
739 if (dig == '9') { /* possible if i == 1 */
740 round_9_up:
741 *s++ = '9';
742 inex = STRTOG_Inexhi;
Value stored to 'inex' is never read
743 goto roundoff;
744 }
745 inex = STRTOG_Inexhi;
746 *s++ = dig + 1;
747 goto ret;
748 }
749 *s++ = dig;
750 if (i == ilim)
751 break;
752 b = multadd__multadd_D2A(b, 10, 0);
753 if (b == NULL((void*)0))
754 return (NULL((void*)0));
755 if (mlo == mhi) {
756 mlo = mhi = multadd__multadd_D2A(mhi, 10, 0);
757 if (mlo == NULL((void*)0))
758 return (NULL((void*)0));
759 }
760 else {
761 mlo = multadd__multadd_D2A(mlo, 10, 0);
762 if (mlo == NULL((void*)0))
763 return (NULL((void*)0));
764 mhi = multadd__multadd_D2A(mhi, 10, 0);
765 if (mhi == NULL((void*)0))
766 return (NULL((void*)0));
767 }
768 }
769 }
770 else
771 for(i = 1;; i++) {
772 *s++ = dig = quorem__quorem_D2A(b,S) + '0';
773 if (i >= ilim)
774 break;
775 b = multadd__multadd_D2A(b, 10, 0);
776 if (b == NULL((void*)0))
777 return (NULL((void*)0));
778 }
779
780 /* Round off last digit */
781
782 if (rdir) {
783 if (rdir == 2 || (b->wds <= 1 && !b->x[0]))
784 goto chopzeros;
785 goto roundoff;
786 }
787 b = lshift__lshift_D2A(b, 1);
788 if (b == NULL((void*)0))
789 return (NULL((void*)0));
790 j = cmp__cmp_D2A(b, S);
791#ifdef ROUND_BIASED
792 if (j >= 0)
793#else
794 if (j > 0 || (j == 0 && dig & 1))
795#endif
796 {
797 roundoff:
798 inex = STRTOG_Inexhi;
799 while(*--s == '9')
800 if (s == s0) {
801 k++;
802 *s++ = '1';
803 goto ret;
804 }
805 ++*s++;
806 }
807 else {
808 chopzeros:
809 if (b->wds > 1 || b->x[0])
810 inex = STRTOG_Inexlo;
811 while(*--s == '0'){}
812 ++s;
813 }
814 ret:
815 Bfree__Bfree_D2A(S);
816 if (mhi) {
817 if (mlo && mlo != mhi)
818 Bfree__Bfree_D2A(mlo);
819 Bfree__Bfree_D2A(mhi);
820 }
821 ret1:
822 Bfree__Bfree_D2A(b);
823 *s = 0;
824 *decpt = k + 1;
825 if (rve)
826 *rve = s;
827 *kindp |= inex;
828 return s0;
829 }
830DEF_STRONG(gdtoa)__asm__(".global " "__gdtoa" " ; " "__gdtoa" " = " "_libc___gdtoa"
)
;