Browse Source

math: excess precision fix modf, modff, scalbn, scalbnf

old code was correct only if the result was stored (without the
excess precision) or musl was compiled with -ffloat-store.
now we use STRICT_ASSIGN to work around the issue.
(see note 160 in c11 section 6.8.6.4)
rs-1.0
Szabolcs Nagy 14 years ago
parent
commit
c4359e0130
  1. 6
      src/math/modf.c
  2. 6
      src/math/modff.c
  3. 14
      src/math/scalbn.c
  4. 14
      src/math/scalbnf.c

6
src/math/modf.c

@ -1,5 +1,4 @@
#include <math.h> #include "libm.h"
#include <stdint.h>
double modf(double x, double *iptr) double modf(double x, double *iptr)
{ {
@ -33,5 +32,6 @@ double modf(double x, double *iptr)
} }
u.n &= ~mask; u.n &= ~mask;
*iptr = u.x; *iptr = u.x;
return x - *iptr; STRICT_ASSIGN(double, x, x - *iptr);
return x;
} }

6
src/math/modff.c

@ -1,5 +1,4 @@
#include <math.h> #include "libm.h"
#include <stdint.h>
float modff(float x, float *iptr) float modff(float x, float *iptr)
{ {
@ -33,5 +32,6 @@ float modff(float x, float *iptr)
} }
u.n &= ~mask; u.n &= ~mask;
*iptr = u.x; *iptr = u.x;
return x - *iptr; STRICT_ASSIGN(float, x, x - *iptr);
return x;
} }

14
src/math/scalbn.c

@ -2,8 +2,6 @@
double scalbn(double x, int n) double scalbn(double x, int n)
{ {
/* make sure result is stored as double on overflow or underflow */
volatile double z;
double scale; double scale;
if (n > 1023) { if (n > 1023) {
@ -13,8 +11,8 @@ double scalbn(double x, int n)
x *= 0x1p1023; x *= 0x1p1023;
n -= 1023; n -= 1023;
if (n > 1023) { if (n > 1023) {
z = x * 0x1p1023; STRICT_ASSIGN(double, x, x * 0x1p1023);
return z; return x;
} }
} }
} else if (n < -1022) { } else if (n < -1022) {
@ -24,12 +22,12 @@ double scalbn(double x, int n)
x *= 0x1p-1022; x *= 0x1p-1022;
n += 1022; n += 1022;
if (n < -1022) { if (n < -1022) {
z = x * 0x1p-1022; STRICT_ASSIGN(double, x, x * 0x1p-1022);
return z; return x;
} }
} }
} }
INSERT_WORDS(scale, (uint32_t)(0x3ff+n)<<20, 0); INSERT_WORDS(scale, (uint32_t)(0x3ff+n)<<20, 0);
z = x * scale; STRICT_ASSIGN(double, x, x * scale);
return z; return x;
} }

14
src/math/scalbnf.c

@ -2,8 +2,6 @@
float scalbnf(float x, int n) float scalbnf(float x, int n)
{ {
/* make sure result is stored as double on overflow or underflow */
volatile float z;
float scale; float scale;
if (n > 127) { if (n > 127) {
@ -13,8 +11,8 @@ float scalbnf(float x, int n)
x *= 0x1p127f; x *= 0x1p127f;
n -= 127; n -= 127;
if (n > 127) { if (n > 127) {
z = x * 0x1p127f; STRICT_ASSIGN(float, x, x * 0x1p127f);
return z; return x;
} }
} }
} else if (n < -126) { } else if (n < -126) {
@ -24,12 +22,12 @@ float scalbnf(float x, int n)
x *= 0x1p-126f; x *= 0x1p-126f;
n += 126; n += 126;
if (n < -126) { if (n < -126) {
z = x * 0x1p-126f; STRICT_ASSIGN(float, x, x * 0x1p-126f);
return z; return x;
} }
} }
} }
SET_FLOAT_WORD(scale, (uint32_t)(0x7f+n)<<23); SET_FLOAT_WORD(scale, (uint32_t)(0x7f+n)<<23);
z = x * scale; STRICT_ASSIGN(float, x, x * scale);
return z; return x;
} }

Loading…
Cancel
Save