@@ -55,10 +55,11 @@ as_acosh_one (double x, double sh, double sl)
{ -0x1.3fde50d0cb4b9p-16, 0x1.0335101403d9dp-72 },
{ 0x1.12ef3bf8a0a74p-17, 0x1.f9c6b51787043p-80 } };
- static const double cl[]
+ static const double cl_data[]
= { -0x1.df3b9d1296ea9p-19, 0x1.a681d7d2298ebp-20,
-0x1.77ead7b1ca449p-21, 0x1.4edd2ddb3721fp-22,
-0x1.1bf173531ee23p-23, 0x1.613229230e255p-25 };
+ const double *cl = ptr_barrier (cl_data);
double y2
= x
@@ -66,7 +67,7 @@ as_acosh_one (double x, double sh, double sl)
+ x
* (cl[1]
+ x * (cl[2] + x * (cl[3] + x * (cl[4] + x * (cl[5]))))));
- double y1 = polydd3 (x, 0, 10, ch, &y2);
+ double y1 = polydd3 (x, 0, 10, ptr_barrier (ch), &y2);
y1 = mulddd (y1, y2, x, &y2);
double y0 = fasttwosum (1, y1, &y1);
y1 += y2;
@@ -105,11 +106,12 @@ __ieee754_acosh (double x)
double iz = (-0.25) / z, zt = 2 * z;
double sh = sqrt (zt),
sl = fma (sh, sh, -zt) * (sh * iz);
- static const double cl[] = {
+ static const double cl_data[] = {
-0x1.5555555555555p-4, 0x1.3333333332f95p-6, -0x1.6db6db6d5534cp-8,
0x1.f1c71c1e04356p-10, -0x1.6e8b8e3e40d58p-11, 0x1.1c4ba825ac4fep-12,
-0x1.c9045534e6d9ep-14, 0x1.71fedae26a76bp-15, -0x1.f1f4f8cc65342p-17
};
+ const double *cl = ptr_barrier (cl_data);
double z2 = z * z, z4 = z2 * z2,
ds = fma (
sh * z,
@@ -146,9 +148,10 @@ __ieee754_acosh (double x)
{
/* 111.75 <= x < 738: this branch was tested exhaustively
with/without FMA contraction */
- static const double cl[]
+ static const double cl_data[]
= { 0x1.5c4b6148816e2p-66, -0x1.000000000005cp-2,
-0x1.7fffffebf3e6cp-4, -0x1.aab6691f2bae7p-5 };
+ const double *cl = ptr_barrier (cl_data);
double z = 1 / (x * x);
g = cl[0] + z * (cl[1] + z * (cl[2] + z * cl[3]));
eps = 0x1.c3p-63;
@@ -157,9 +160,10 @@ __ieee754_acosh (double x)
{
/* 738 <= x < 32896: this branch was tested exhaustively
with/without FMA contraction */
- static const double cl[]
+ static const double cl_data[]
= { -0x1.7f77c8429c6c6p-67, -0x1.ffffffffff214p-3,
-0x1.8000268641bfep-4 };
+ const double *cl = ptr_barrier (cl_data);
double z = 1 / (x * x);
g = cl[0] + z * (cl[1] + z * cl[2]);
eps = 0x1.9ap-63;
@@ -169,8 +173,9 @@ __ieee754_acosh (double x)
// 32896 <= x < 0x1.ap+31
/* this branch was tested exhaustively with/without FMA contraction
only for 32896 <= x < 2^16. */
- static const double cl[]
+ static const double cl_data[]
= { 0x1.7a0ed2effdd1p-67, -0x1.000000017d048p-2 };
+ const double *cl = ptr_barrier (cl_data);
double z = 1 / (x * x);
g = cl[0] + z * cl[1];
eps = 0x1.99p-63;
@@ -368,8 +373,9 @@ as_acosh_refine (double x, double a)
{ -0x1p-2, -0x1.932ce43199a8dp-110 },
{ 0x1.5555555555555p-3, 0x1.55540c15cf91fp-57 },
};
- static const double cl[3]
+ static const double cl_data[3]
= { -0x1p-3, 0x1.9999999a0754fp-4, -0x1.55555555c3157p-4 };
+ const double *cl = ptr_barrier (cl_data);
uint64_t ix = asuint64 (x);
double zh, zl;
int huge = 0; // exponent adjustment
@@ -441,7 +447,7 @@ as_acosh_refine (double x, double a)
}
xh = adddd2 (xh, xl, sh, sl, &xl);
sl = xh * (cl[0] + xh * (cl[1] + xh * cl[2]));
- sh = polydd3 (xh, xl, 3, ch, &sl);
+ sh = polydd3 (xh, xl, 3, ptr_barrier (ch), &sl);
sh = muldd_acc2 (xh, xl, sh, sl, &sl);
sh = adddd2 (sh, sl, el1, el2, &sl);
sh = adddd2 (sh, sl, L[1], L[2], &sl);
@@ -99,11 +99,13 @@ __ieee754_atanh (double x)
* for 0x1.d12ed0af1a27fp-27 <= x < 2^-24
*/
double x2 = x * x;
- static const double c[] = { 0x1.999999999999ap-3, 0x1.2492492492244p-3,
- 0x1.c71c71c79715fp-4, 0x1.745d16f777723p-4,
- 0x1.3b13ca4174634p-4, 0x1.110c9724989bdp-4,
- 0x1.e2d17608a5b2ep-5, 0x1.a0b56308cba0bp-5,
- 0x1.fb6341208ad2ep-5 };
+ static const double c_data[] =
+ {
+ 0x1.999999999999ap-3, 0x1.2492492492244p-3, 0x1.c71c71c79715fp-4,
+ 0x1.745d16f777723p-4, 0x1.3b13ca4174634p-4, 0x1.110c9724989bdp-4,
+ 0x1.e2d17608a5b2ep-5, 0x1.a0b56308cba0bp-5, 0x1.fb6341208ad2ep-5
+ };
+ const double *c = ptr_barrier (c_data);
double dx2 = fma (x, x, -x2);
double x4 = x2 * x2, x3 = x2 * x, x8 = x4 * x4;
double dx3 = fma (x2, x, -x3) + dx2 * x;
@@ -128,9 +130,10 @@ __ieee754_atanh (double x)
tl = fma (ph, iqh, -th)
+ (pl + ph * (fma (-qh, iqh, 1) - ql * iqh)) * iqh;
- static const double c[]
+ static const double c_data[]
= { -0x1p+0, 0x1.555555555553p+0, -0x1.fffffffffffap+0,
0x1.99999e33a6366p+1, -0x1.555559ef9525fp+2 };
+ const double *c = ptr_barrier (c_data);
uint64_t t = asuint64 (th);
int ex = t >> 52, e = ex - 0x3ff;
@@ -194,8 +197,9 @@ as_atanh_database (double x, double f)
static double
as_atanh_refine (double x, double zh, double zl, double a)
{
- static const double cl[3]
+ static const double cl_data[3]
= { -0x1p-3, 0x1.9999999a0754fp-4, -0x1.55555555c3157p-4 };
+ const double *cl = ptr_barrier (cl_data);
uint64_t t = asuint64 (zh);
int ex = t >> 52, e = ex - 0x3ff;
t &= ~UINT64_C (0) >> 12;
@@ -74,7 +74,7 @@ as_exp_accurate (double x, double t, double th, double tl, double *l)
double fl = dxh
* (0x1.5555555555555p-5
+ dxh * (0x1.11111113e93e9p-7 + dxh * 0x1.6c16c169400a7p-10));
- double fh = polydd_cosh (dxh, dxl, 3, ch, &fl);
+ double fh = polydd_cosh (dxh, dxl, 3, ptr_barrier (ch), &fl);
fh = muldd2 (dxh, dxl, fh, fl, &fl);
fh = muldd2 (th, tl, fh, fl, &fl);
double zh = th + fh, zl = (th - zh) + fh;
@@ -154,11 +154,12 @@ __cosh (double x)
q=1+x^2*fpminimax((cosh(x)-1)/x^2, [|0,2,4,6,8|], [|53...|], d,
absolute);
*/
- static const double c[] =
+ static const double c_data[] =
{
0x1p-1, 0x1.5555555555554p-5, 0x1.6c16c16c1d0cp-10,
0x1.a01a0075066b4p-16, 0x1.27faff8dcc1c8p-22
};
+ const double *c = ptr_barrier (c_data);
double x2 = x * x, x4 = x2 * x2,
p
= x2
@@ -198,8 +199,9 @@ __cosh (double x)
double th = t0h * t1h, tl = t0h * t1l + t1h * t0l + fma (t0h, t1h, -th);
const double l2h = 0x1.62e42ffp-13, l2l = 0x1.718432a1b0e26p-47;
double dx = (ax - l2h * t) + l2l * t, dx2 = dx * dx, mx = -dx;
- static const double ch[]
+ static const double ch_data[]
= { 0x1p+0, 0x1p-1, 0x1.5555555aaaaaep-3, 0x1.55555551c98cp-5 };
+ const double *ch = ptr_barrier (ch_data);
double pp = dx * ((ch[0] + dx * ch[1]) + dx2 * (ch[2] + dx * ch[3]));
double rh, rl;
if (__glibc_unlikely (aix > UINT64_C(0x4014000000000000)))
@@ -194,17 +194,18 @@ as_tgamma_accurate (double x)
{ 0x1.fffc7cf7439c3p-1, -0x1.2599c887c744ap-55 },
{ -0x1.001452e7ff0b7p+0, -0x1.acc4a235f0de4p-56 },
{ 0x1.001c6c5b18192p+0, 0x1.35874aa96ce14p-54 } };
- static const double c[]
+ static const double c_data[]
= { -0x1.fdf5126e6a83bp-1, 0x1.fd56c1b531709p-1,
-0x1.0956741759e58p+0, 0x1.0b6167d27c5c4p+0,
-0x1.8e69e55b6dcap-1, 0x1.7e124660c827dp-1,
-0x1.c797b42bd6745p+0, 0x1.d688bb8db046cp+0 };
+ const double *c = ptr_barrier (c_data);
double x2 = x * x, x4 = x2 * x2;
double c0 = c[0] + x * c[1] + x2 * (c[2] + x * c[3]);
double c4 = c[4] + x * c[5] + x2 * (c[6] + x * c[7]);
c0 += x4 * c4;
- double cl = x * c0, ch = polyddd (x, 28, cc, &cl);
+ double cl = x * c0, ch = polyddd (x, 28, ptr_barrier (cc), &cl);
double fh = 1.0 / x, dh = fma (fh, -x, 1.0), fl = dh * fh,
fll = fma (fl, -x, dh) * fh;
fl = sumdd (fl, fll, ch, cl, &fll);
@@ -740,14 +741,16 @@ __ieee754_gamma_r (double x, int *signgamp)
{ -0x1.d0a118f324b6p-1, -0x1.bb37df476a7ccp-55 },
{ 0x1.f6a51055097c6p-1, -0x1.30eee7e7c5482p-55 },
{ -0x1.f6c80ec38bc47p-1, -0x1.22885891ee90dp-56 } };
- static const double c[] = { 0x1.fc7e0a6e9c2c9p-1, -0x1.fdf3f15764246p-1,
- 0x1.ff07b5af9892cp-1, -0x1.ff803d8f584c4p-1,
- 0x1.ffc07f59b072bp-1, -0x1.ffe00e422ee2ep-1,
- 0x1.fff102b561602p-1, -0x1.fff9cb7b72f3bp-1,
- 0x1.ffdcb35bbec92p-1, -0x1.ffcc551b96878p-1,
- 0x1.013dde0ace169p+0, -0x1.01baffd0f7e86p+0,
- 0x1.e15c8c643ed7ap-1, -0x1.da0418fdfaac3p-1,
- 0x1.665b8c5abe55p+0, -0x1.721c7bc0d07cp+0 };
+ static const double c_data[]
+ = { 0x1.fc7e0a6e9c2c9p-1, -0x1.fdf3f15764246p-1,
+ 0x1.ff07b5af9892cp-1, -0x1.ff803d8f584c4p-1,
+ 0x1.ffc07f59b072bp-1, -0x1.ffe00e422ee2ep-1,
+ 0x1.fff102b561602p-1, -0x1.fff9cb7b72f3bp-1,
+ 0x1.ffdcb35bbec92p-1, -0x1.ffcc551b96878p-1,
+ 0x1.013dde0ace169p+0, -0x1.01baffd0f7e86p+0,
+ 0x1.e15c8c643ed7ap-1, -0x1.da0418fdfaac3p-1,
+ 0x1.665b8c5abe55p+0, -0x1.721c7bc0d07cp+0 };
+ const double *c = ptr_barrier (c_data);
double x2 = x * x, x4 = x2 * x2, x8 = x4 * x4;
double c0 = c[0] + x * c[1] + x2 * (c[2] + x * c[3]);
double c4 = c[4] + x * c[5] + x2 * (c[6] + x * c[7]);
@@ -756,7 +759,7 @@ __ieee754_gamma_r (double x, int *signgamp)
c0 += x4 * c4;
c8 += x4 * c12;
double cl = x * (c0 + x8 * c8);
- double ch = polyddd (x, 5, cc, &cl);
+ double ch = polyddd (x, 5, ptr_barrier (cc), &cl);
double fh = 1.0 / z, fl = fma (fh, -z, 1.0) * fh;
fh = fastsum (fh, fl, ch, cl, &fl);
double eps = fh * (3.5e-19 + (x2 * x4) * 4e-15);
@@ -883,7 +886,7 @@ __ieee754_gamma_r (double x, int *signgamp)
{ 0x1.432cdb3640fcap-26, -0x1.33987f0b3b6b6p-81 },
{ 0x1.f239fc9cf2155p-29, -0x1.8a95d04bfb2e4p-83 },
{ 0x1.e3ea4e1366932p-33, -0x1.5c950f5465458p-93 } };
- static const double c[] = {
+ static const double c_data[] = {
0x1.a96390899a074p+1, 0x1.d545472146024p+1, 0x1.491ad1cb98836p+1,
0x1.4a0b6a8230929p+0, 0x1.0e5d232b95859p-1, 0x1.71d1672129feep-3,
0x1.bd2afde7e4816p-5, 0x1.d8376e1031a16p-7, 0x1.c9e94992c88c1p-9,
@@ -891,13 +894,14 @@ __ieee754_gamma_r (double x, int *signgamp)
0x1.65e5a18d31c17p-18, 0x1.ca1890add8727p-21, 0x1.378b3b91f9033p-23,
0x1.432cdb3640fcap-26, 0x1.f239fc9cf2155p-29, 0x1.e3ea4e1366932p-33
};
+ const double *c = ptr_barrier (c_data);
double m = z - 0x1.cp+1, i = roundeven_finite (m);
double d = z - (i + 0x1.cp+1);
double d2 = d * d, d4 = d2 * d2;
double fl = d
* ((c[10] + d * c[11]) + d2 * (c[12] + d * c[13])
+ d4 * ((c[14] + d * c[15]) + d2 * (c[16] + d * c[17])));
- double fh = polyddd (d, 10, cc, &fl);
+ double fh = polyddd (d, 10, ptr_barrier (cc), &fl);
int jm = fabs (i);
double wh = 1, wl = 0;
double xph = z, xpl = 0;
@@ -1038,8 +1042,9 @@ libm_alias_finite (__ieee754_gamma_r, __gamma_r)
double r = r1[i1] * r2[i2];
double tf = asdouble (t);
double o = r * tf, dxl = fma (r, tf, -o), dxh = o - 1;
- static const double c[] = { -0x1.fffffffffffd3p-2, 0x1.55555555543d5p-2,
- -0x1.000002bb2d74ep-2, 0x1.999a692c56e4ep-3 };
+ static const double c_data[] = { -0x1.fffffffffffd3p-2, 0x1.55555555543d5p-2,
+ -0x1.000002bb2d74ep-2, 0x1.999a692c56e4ep-3 };
+ const double *c = ptr_barrier (c_data);
double dx = fma (r, tf, -1), dx2 = dx * dx;
double f = dx2 * ((c[0] + dx * c[1]) + dx2 * (c[2] + dx * c[3]));
double lt = (l1[i1][1] + l2[i2][1]) + ed * 0x1.62e42fef8p-1;
@@ -1128,11 +1133,15 @@ as_sinpid (double x, double *l)
double sh = st[kx][1], sl = st[kx][0];
double ch = st[ky][1], cl = st[ky][0];
- static const double c[] = { -0x1.3bd3cc9be45dep-12, 0x1.03c1f081b5ac4p-26,
- -0x1.55d3c7e3bd8bfp-42, 0x1.e1f4826790653p-59 };
+ static const double c_data[]
+ = { -0x1.3bd3cc9be45dep-12, 0x1.03c1f081b5ac4p-26,
+ -0x1.55d3c7e3bd8bfp-42, 0x1.e1f4826790653p-59 };
+ const double *c = ptr_barrier (c_data);
double c0 = -0x1.692b66e3cf6e8p-66;
- static const double s[] = { 0x1.921fb54442d18p-6, -0x1.4abbce625be53p-19,
- 0x1.466bc67748efcp-34, -0x1.32d26e446373ap-50 };
+ static const double s_data[]
+ = { 0x1.921fb54442d18p-6, -0x1.4abbce625be53p-19,
+ 0x1.466bc67748efcp-34, -0x1.32d26e446373ap-50 };
+ const double *s = ptr_barrier (s_data);
double s0 = 0x1.1a624b88c9448p-60;
double P = d2 * (c[1] + d2 * (c[2] + d2 * c[3]));
@@ -1228,12 +1237,13 @@ as_expd (double x, double *l, int *e)
int k = ix, i0 = (k >> 5) & 31, i1 = k & 31;
*e = k >> 10;
double rl, rh = muldd2 (E0[i0][1], E0[i0][0], E1[i1][1], E1[i1][0], &rl);
- static const double c[][2]
+ static const double c_data[][2]
= { { 0x1.62e42fefa39efp-11, 0x1.abc9e3bf9d4d1p-66 },
{ 0x1.ebfbdff82c58ep-23, 0x1.ec07243b4e585p-77 },
{ 0x1.c6b08d704a0bfp-35, 0x1.94bac118264d5p-89 },
{ 0x1.3b2ab719edc2dp-47, 0x1.b530cee32e3dep-101 },
{ 0x1.5d87fe98a5fc4p-60, -0x1.63e85fdbde1cap-115 } };
+ const double (*c)[2] = ptr_barrier (c_data);
const int m = 1;
double fh, fl, el;
fl = xh * polyd (xh, 5 - m, c + m);
@@ -1258,7 +1268,7 @@ as_lgamma_asym (double xh, double *xl)
double x2 = z2h * z2h;
if (xh > 11.5)
{
- static const double c[][2]
+ static const double c_data[][2]
= { { 0x1.acfe390c97d69p-2, 0x1.34acf208a22c4p-56 },
{ 0x1.5555555555555p-4, 0x1.31799ffbcdddbp-58 },
{ -0x1.6c16c16c165a9p-9, 0x1.1eefaee02f69p-63 },
@@ -1267,6 +1277,7 @@ as_lgamma_asym (double xh, double *xl)
{ 0x1.b9486dc1c9886p-11, -0x1.2dac4b8cca031p-65 },
{ -0x1.f3ecd8799f337p-10, 0x1.da5dd745e3963p-64 },
{ 0x1.6d399e561839p-8, 0x1.15e3000de141ap-62 } };
+ const double (*c)[2] = ptr_barrier (c_data);
lh = fastsum (lh, ll, c[0][0], c[0][1], &ll);
const int k = 1;
const double (*b)[2] = c + 1, (*q)[2] = c + 1 + k;
@@ -1278,7 +1289,7 @@ as_lgamma_asym (double xh, double *xl)
}
else
{
- static const double c[][2]
+ static const double c_data[][2]
= { { 0x1.acfe390c97d69p-2, 0x1.f06a157d44d5bp-56 },
{ 0x1.5555555555541p-4, 0x1.9d5fc10df4161p-58 },
{ -0x1.6c16c16bfb733p-9, -0x1.557d8fba9e97ap-64 },
@@ -1292,6 +1303,7 @@ as_lgamma_asym (double xh, double *xl)
{ -0x1.2beb46518ed4ap-1, -0x1.0298c44c99ceep-58 },
{ 0x1.e5717107e0999p+0, 0x1.5bdfe7ac38f81p-56 },
{ -0x1.90c04fbd840a6p+1, -0x1.5d2fbfe47e148p-54 } };
+ const double (*c)[2] = ptr_barrier (c_data);
lh = fastsum (lh, ll, c[0][0], c[0][1], &ll);
double x4 = x2 * x2;
const int k = 2;
@@ -328,9 +328,10 @@ as_lgamma_accurate (double x)
{
if (fabs (fh) < 0x1.74p-4 && sx > SX_BND && sx < -2)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.3a7fc9600f86cp+1, 0x1.55f64f98af8dp-55,
0x1.c4b0cd201366ap-110 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.83fe966af535fp+0, -0x1.775909a36a68cp-55 },
{ 0x1.36eebb002f55dp-1, -0x1.8d4b2124a39f8p-55 },
@@ -363,15 +364,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.168p-4 && sx > -3 && sx < SX_BND)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.5fb410a1bd901p+1, -0x1.a19a96d2e6f85p-54,
-0x1.140b4ff4b7d6p-108 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.ea12da904b18cp+0, -0x1.220130f99b2cbp-54 },
{ 0x1.3267f3c265a52p-1, -0x1.1c630ff19db83p-55 },
@@ -405,15 +407,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.2d4p-4 && sx > -3.5 && sx < -3)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.9260dbc9e59afp+1, 0x1.f717cd335a7b3p-53,
0x1.d32a2a65bfd63p-107 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.f20a65f2fac55p+2, -0x1.1d258e4b0beb5p-53 },
{ 0x1.9d4d2977150efp-2, 0x1.a04089578ae88p-56 },
@@ -440,15 +443,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 7;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.efp-5 && sx > -4 && sx < -3.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.fa471547c2fe5p+1, 0x1.70d4561291237p-56,
-0x1.9e6fadbbc171ap-111 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.4b99d966c5647p+4, 0x1.9cba2450b0003p-50 },
{ 0x1.f76deae0436bep-1, -0x1.5af99a1af2d4bp-55 },
@@ -475,15 +479,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 7;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1p-3 && sx > -4.5 && sx < -4)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.0284e78599581p+2, -0x1.e78c1e9e43cfep-53,
0x1.2ac17bfd6be92p-108 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.aca5cf4921642p+4, 0x1.a46a2e0d8fdfdp-51 },
{ 0x1.44415cd813f8ep+1, 0x1.afdc2672876f4p-56 },
@@ -514,15 +519,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 7;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.08p-4 && sx > -5 && sx < -4.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.3f7577a6eeafdp+2, -0x1.5de5eab7f12cfp-53,
0x1.4075f5e0494a2p-110 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.d224a3ef9e41fp+6, -0x1.9be272a13bcb6p-48 },
{ 0x1.b533c678a3956p+2, -0x1.37da6a2b62e3cp-53 },
@@ -548,15 +554,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 7;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.1p-4 && sx > -5.5 && sx < -5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.4086a57f0b6d9p+2, 0x1.95262b72ca9cap-55,
0x1.bd98d5e0861aap-109 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.ed72e0829ae02p+6, -0x1.fdc1859ae9c53p-50 },
{ 0x1.cecc32ec22f9bp+2, 0x1.b6ecc779b86fcp-53 },
@@ -582,15 +589,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.13p-3 && sx > -6 && sx < -5.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.7fe92f591f40dp+2, 0x1.7dd4ed62cbd32p-52,
-0x1.2071c071a2146p-108 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.661f6a43a5e12p+9, -0x1.0c437b83bc0ddp-45 },
{ 0x1.f79dcb794f26fp+5, -0x1.ada8018ade6efp-52 },
@@ -621,15 +629,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.15p-3 && sx > -6.5 && sx < -6)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.8016b25897c8dp+2, -0x1.27e0f49a4ba72p-54,
0x1.72e1ab15a4d03p-110 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.69de49e3af2aap+9, 0x1.954b690943afcp-47 },
{ 0x1.fce23484cfd1p+5, 0x1.8266e7580f08cp-49 },
@@ -660,15 +669,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.34p-3 && sx > -7.0 && sx < -6.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.bffcbf76b86fp+2, -0x1.853b29347b806p-57,
0x1.0fa018051dd41p-111 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.3abf7a5cea91bp+12, -0x1.8257b8abd02cep-42 },
{ 0x1.8349a2550422dp+9, -0x1.c6f2ef4105b99p-45 },
@@ -700,15 +710,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.145p-3 && sx > -7.5 && sx < -7)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.c0033fdedfe1fp+2, -0x1.20bb7d2324678p-52,
-0x1.f5536678d69d3p-106 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.3b407aa387bd1p+12, 0x1.da1e57343b1dbp-43 },
{ 0x1.83e85daafbad6p+8, -0x1.f37538d99bd29p-46 },
@@ -739,15 +750,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.76bp-3 && sx > -8 && sx < -7.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.ffff97f8159cfp+2, 0x1.e54f415a91586p-55,
0x1.53a5d106f9a3ep-109 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.3af76fe4c2fabp+15, -0x1.7cc92f0b999ep-40 },
{ 0x1.838e76caaf123p+12, 0x1.292e15f502d1fp-42 },
@@ -781,16 +793,17 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.76cp-3 && sx > -0x1.10f5c28f5c28fp+3
&& sx < -8)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.000034028b3f9p+3, 0x1.f60cb3cec1cedp-52,
-0x1.ea26620d6b1cap-106 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.3b088fed67718p+15, -0x1.505613ba29893p-39 },
{ 0x1.83a3893550edcp+12, 0x1.f52e3b240db3p-42 },
@@ -824,15 +837,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.99p-3 && sx > -9 && sx < -8.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.1ffffa3884bdp+3, 0x1.ff90c9d2ae925p-53,
-0x1.30c0efef78c04p-107 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.625edfc63db2fp+18, 0x1.da7fc3ed68f99p-37 },
{ 0x1.ea8c150480a7ap+15, 0x1.344e4cbf6d2a1p-39 },
@@ -867,15 +881,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.99p-3 && sx > -9.5 && sx < -9)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.200005c7768fbp+3, 0x1.b5b610ffb70d4p-54,
0x1.deb7ad09ec5eap-108 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.626120391944p+18, 0x1.7d5e8272ce41dp-38 },
{ 0x1.ea8f32fb7f586p+15, -0x1.345b1cc20d4a5p-39 },
@@ -910,15 +925,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.76bp-3 && sx > -10 && sx < -9.5)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.3fffff6c0d7cp+3, -0x1.197cea8c42d7dp-51,
-0x1.7072c5a292198p-105 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { -0x1.baf7da5f3795dp+21, -0x1.16a79518c8367p-33 },
{ 0x1.7f3e8791fa0d2p+18, -0x1.2aec811c9609ep-36 },
@@ -952,15 +968,16 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
else if (fabs (fh) < 0x1.76bp-3 && sx > -10.5 && sx < -10)
{
- static const double x0[]
+ static const double x0_data[]
= { 0x1.40000093f2777p+3, 0x1.927b45d95e154p-52,
0x1.0780c21b6e452p-106 };
+ const double *x0 = ptr_barrier (x0_data);
static const double c[][2]
= { { 0x1.baf825a0c63b2p+21, -0x1.20323f1015cdfp-35 },
{ 0x1.7f3ec8ae05f2ep+18, 0x1.2aec80d23ccb8p-36 },
@@ -994,8 +1011,8 @@ as_lgamma_accurate (double x)
zl += x0[2];
double sh = zh * sc, sl = zl * sc;
int n = array_length (c), k = 6;
- fl = sh * polyd (sh, k, c + n - k);
- fh = polydd2 (sh, sl, n - k, c, &fl);
+ fl = sh * polyd (sh, k, ptr_barrier (c) + n - k);
+ fh = polydd2 (sh, sl, n - k, ptr_barrier (c), &fl);
fh = muldd2 (zh, zl, fh, fl, &fl);
}
}
@@ -1240,16 +1257,17 @@ __ieee754_lgamma_r (double x, int *signgamp)
{ 0x1.a51a6625307d3p-1, 0x1.18722054895e9p-56 },
{ -0x1.9a4d55beab2d7p-2, -0x1.74ded0474fe66p-63 },
{ 0x1.151322ac7d848p-2, 0x1.825b3df1d5722p-56 } };
- static const double q[]
+ static const double q_data[]
= { -0x1.a8b9c17aa5d3dp-3, 0x1.5b40cb100b9bfp-3,
-0x1.2703a1e13bcbcp-3, 0x1.010b36b6afdc1p-3,
-0x1.c8062dd09ec62p-4, 0x1.9a018c7345316p-4,
-0x1.7578ea8068cc4p-4, 0x1.566b51c990008p-4 };
+ const double *q = ptr_barrier (q_data);
double z = x, z2 = z * z, z4 = z2 * z2;
double q0 = q[0] + z * q[1], q2 = q[2] + z * q[3],
q4 = q[4] + z * q[5], q6 = q[6] + z * q[7];
fl = z * ((q0 + z2 * q2) + z4 * (q4 + z2 * q6));
- fh = polydddfst (z, 4, c0, &fl);
+ fh = polydddfst (z, 4, ptr_barrier (c0), &fl);
fh = mulddd2 (x, fh, fl, &fl);
fh = sumdd (-lh, -ll, fh, fl, &fl);
eps = 1.5e-22;
@@ -1302,13 +1320,15 @@ __ieee754_lgamma_r (double x, int *signgamp)
// for other |x| use a simple product
lh = mulddd2 (ax - 0.5, lh, ll, &ll);
}
- static const double c[][2]
+ static const double c_data[][2]
= { { 0x1.acfe390c97d6ap-2, -0x1.1d9792ced423ap-58 },
{ 0x1.55555555554c1p-4, -0x1.0143af34001bdp-59 } };
- static const double q[]
+ const double (*c)[2] = ptr_barrier (c_data);
+ static const double q_data[]
= { -0x1.6c16c1697de08p-9, 0x1.a019f47b230fdp-11,
-0x1.380aab821e42ep-11, 0x1.b617d2c5b5b66p-11,
-0x1.a7fd66a05ccfcp-10 };
+ const double *q = ptr_barrier (q_data);
lh = fastsum (lh, ll, c[0][0], c[0][1], &ll);
if (ax < 0x1p100)
{
@@ -1497,8 +1517,9 @@ double as_logd (double x, double *l)
double r = r1[i1] * r2[i2];
double tf = asdouble (t);
double o = r * tf, dxl = fma (r, tf, -o), dxh = o - 1;
- static const double c[] = { -0x1.fffffffffffd3p-2, 0x1.55555555543d5p-2,
- -0x1.000002bb2d74ep-2, 0x1.999a692c56e4ep-3 };
+ static const double c_data[] = { -0x1.fffffffffffd3p-2, 0x1.55555555543d5p-2,
+ -0x1.000002bb2d74ep-2, 0x1.999a692c56e4ep-3 };
+ const double *c = ptr_barrier (c_data);
double dx = fma (r, tf, -1), dx2 = dx * dx;
double f = dx2 * ((c[0] + dx * c[1]) + dx2 * (c[2] + dx * c[3]));
double lt = (l1[i1][1] + l2[i2][1]) + ed * 0x1.62e42fef8p-1;
@@ -1635,7 +1656,7 @@ as_logd_accurate (double x, double *l, double *l_)
double r = r1[i1] * r2[i2];
double tf = asdouble (t);
double o = r * tf, dxl = fma (r, tf, -o), dxh = o - 1;
- static const double c[][2]
+ static const double c_data[][2]
= { { 0x1p+0, 0x1.a193d7f59d80ap-118 },
{ -0x1p-1, 0x1.8c7d7a8733406p-99 },
{ 0x1.5555555555555p-2, 0x1.55555554f571dp-56 },
@@ -1645,6 +1666,7 @@ as_logd_accurate (double x, double *l, double *l_)
{ 0x1.249249248dbdcp-3, -0x1.8aa032979ebedp-58 },
{ -0x1.000004e71581bp-3, 0x1.2e7f17d1c0e63p-57 },
{ 0x1.c71e5ec7051f6p-4, 0x1.217ec3dcb2f03p-58 } };
+ const double (*c)[2] = ptr_barrier (c_data);
dxh = fasttwosum (dxh, dxl, &dxl);
double fl = dxh * (c[6][0] + dxh * (c[7][0] + dxh * (c[8][0]))),
fh = polydd2 (dxh, dxl, 6, c, &fl);
@@ -1743,10 +1765,13 @@ as_sinpipid (double x, double *l)
int ky = ix, kx = 64 - ky;
if (__glibc_unlikely (kx < 2))
{
- static const double c[2]
+ static const double c_data[2]
= { -0x1.a51a6625307d3p+0, -0x1.16cc8f2044a4ap-55 };
- static const double cl[] = { 0x1.9f9cb402bc42ap-1, -0x1.86a8e46ddf78dp-3,
- 0x1.ac644e7aa33e6p-6 };
+ const double *c = ptr_barrier (c_data);
+ static const double cl_data[]
+ = { 0x1.9f9cb402bc42ap-1, -0x1.86a8e46ddf78dp-3,
+ 0x1.ac644e7aa33e6p-6 };
+ const double *cl = ptr_barrier (cl_data);
double z = 0.5 - ax, z2 = z * z, z2l = fma (z, z, -z2);
double fl = z2 * (cl[0] + z2 * (cl[1] + z2 * (cl[2]))),
fh = fasttwosum (c[0], fl, &fl), e;
@@ -1766,11 +1791,15 @@ as_sinpipid (double x, double *l)
// sin(a_i + d) = s[i] + d*(c[i]*Q(d^2) - s[i]*d*P(d^2))
// sin(a_i + d)/pi = s[i]/pi + d*(c[i]/pi*Q(d^2) - s[i]/pi*d*P(d^2))
- static const double c[] = { -0x1.3bd3cc9be45dep-12, 0x1.03c1f081b5ac4p-26,
- -0x1.55d3c7e3bd8bfp-42, 0x1.e1f4826790653p-59 };
+ static const double c_data[]
+ = { -0x1.3bd3cc9be45dep-12, 0x1.03c1f081b5ac4p-26,
+ -0x1.55d3c7e3bd8bfp-42, 0x1.e1f4826790653p-59 };
+ const double *c = ptr_barrier (c_data);
double c0 = -0x1.692b66e3cf6e8p-66;
- static const double s[] = { 0x1.921fb54442d18p-6, -0x1.4abbce625be53p-19,
- 0x1.466bc67748efcp-34, -0x1.32d26e446373ap-50 };
+ static const double s_data[]
+ = { 0x1.921fb54442d18p-6, -0x1.4abbce625be53p-19,
+ 0x1.466bc67748efcp-34, -0x1.32d26e446373ap-50 };
+ const double *s = ptr_barrier (s_data);
double s0 = 0x1.1a624b88c9448p-60;
double P = d2 * (c[1] + d2 * (c[2] + d2 * c[3]));
@@ -79,7 +79,7 @@ as_exp_accurate (double x, double t, double th, double tl, double *l)
double fl = dxh
* (0x1.5555555555555p-5
+ dxh * (0x1.11111113e93e9p-7 + dxh * 0x1.6c16c169400a7p-10));
- double fh = polydd_sinh (dxh, dxl, 3, ch, &fl);
+ double fh = polydd_sinh (dxh, dxl, 3, ptr_barrier (ch), &fl);
fh = muldd2 (dxh, dxl, fh, fl, &fl);
fh = muldd2 (th, tl, fh, fl, &fl);
double zh = th + fh, zl = (th - zh) + fh;
@@ -157,9 +157,12 @@ __sinh (double x)
/* With p = c[0]*x^3 + c[1]*x^5 + c[2]*x^7 + c[3]*x^9 + c[4]*x^11,
q = x + p is a minimax approximation of sinh(x) on [x0,1/4] such that
|q - sinh(x)|/x^3 < 2^-56.584 */
- static const double c[] = { 0x1.5555555555555p-3, 0x1.111111111151ep-7,
- 0x1.a01a019d0c767p-13, 0x1.71de444a96e11p-19,
- 0x1.ae8465375242p-26 };
+ static const double c_data[] =
+ {
+ 0x1.5555555555555p-3, 0x1.111111111151ep-7, 0x1.a01a019d0c767p-13,
+ 0x1.71de444a96e11p-19, 0x1.ae8465375242p-26
+ };
+ const double *c = ptr_barrier (c_data);
double x2 = x * x, x3 = x2 * x, x4 = x2 * x2,
p = x3
* ((c[0] + x2 * c[1]) + x4 * ((c[2] + x2 * c[3]) + x4 * c[4]));
@@ -187,8 +190,9 @@ __sinh (double x)
double th = t0h * t1h, tl = t0h * t1l + t1h * t0l + fma (t0h, t1h, -th);
const double l2h = 0x1.62e42ffp-13, l2l = 0x1.718432a1b0e26p-47;
double dx = (ax - l2h * t) + l2l * t, dx2 = dx * dx, mx = -dx;
- static const double ch[]
+ static const double ch_data[]
= { 0x1p+0, 0x1p-1, 0x1.5555555aaaaaep-3, 0x1.55555551c98cp-5 };
+ const double *ch = ptr_barrier (ch_data);
double pp = dx * ((ch[0] + dx * ch[1]) + dx2 * (ch[2] + dx * ch[3]));
double rh, rl;
if (__glibc_unlikely (aix > UINT64_C(0x4014000000000000)))
@@ -50,14 +50,15 @@ as_asinh_zero (double x, double x2h, double x2l)
{ 0x1.12ef3ceae4d12p-7, -0x1.ba9c13deb261fp-61 },
{ -0x1.df3bd104aa267p-8, -0x1.546da9bc5b32ap-62 },
{ 0x1.a685fc5de7a04p-8, 0x1.40d284a1d67f9p-62 } };
- static const double cl[]
+ static const double cl_data[]
= { -0x1.7828d553ec8p-8, 0x1.51712f7bee368p-8, -0x1.2e6d98527bcc6p-8,
0x1.0095da47b392cp-8, -0x1.3b92d6368192cp-9 };
+ const double *cl = ptr_barrier (cl_data);
double y2
= x2h
* (cl[0]
+ x2h * (cl[1] + x2h * (cl[2] + x2h * (cl[3] + x2h * (cl[4])))));
- double y1 = polydd (x2h, x2l, 12, ch, &y2);
+ double y1 = polydd (x2h, x2l, 12, ptr_barrier (ch), &y2);
y1 = muldd_acc (y1, y2, x2h, x2l, &y2);
y1 = mulddd (y1, y2, x, &y2);
@@ -102,21 +103,24 @@ __asinh (double x)
{ // |x| < 0x1p-12
if (__glibc_unlikely (u < UINT64_C (0x3e5a000000000000)))
{ // |x| < 0x1.ap-26
- static const double cl[] = { -0x1.5555555555555p-3 };
+ static const double cl_data[] = { -0x1.5555555555555p-3 };
+ const double *cl = ptr_barrier (cl_data);
sl = x3h * cl[0];
}
else
{
- static const double cl[]
+ static const double cl_data[]
= { -0x1.5555555555555p-3, 0x1.3333327c57c6p-4 };
+ const double *cl = ptr_barrier (cl_data);
sl = x3h * (cl[0] + x2h * cl[1]);
}
}
else
{
- static const double cl[]
+ static const double cl_data[]
= { -0x1.5555555555555p-3, 0x1.333333332f2ffp-4,
-0x1.6db6d9a665159p-5, 0x1.f186866d775fp-6 };
+ const double *cl = ptr_barrier (cl_data);
sl = x3h * (cl[0] + x2h * (cl[1] + x2h * (cl[2] + x2h * cl[3])));
}
}
@@ -127,11 +131,12 @@ __asinh (double x)
This branch (0x1.3p-6 <= x < 0x1.bp-4) was tested exhaustively
by Vincenzo Innocente (both with/without FMA).
All found failures were added to asinh.wc. */
- static const double cl[]
+ static const double cl_data[]
= { -0x1.5555555555555p-3, 0x1.333333333331p-4,
-0x1.6db6db6da466cp-5, 0x1.f1c71c2ea7be4p-6,
-0x1.6e8b651b09d72p-6, 0x1.1c309fc0e69c2p-6,
-0x1.bab7833c1ep-7 };
+ const double *cl = ptr_barrier (cl_data);
double c1 = cl[1] + x2h * cl[2];
double c3 = cl[3] + x2h * cl[4];
double c5 = cl[5] + x2h * cl[6];
@@ -375,8 +380,9 @@ as_asinh_refine (double x, double zh, double zl, double a)
{ -0x1p-2, -0x1.932ce43199a8dp-110 },
{ 0x1.5555555555555p-3, 0x1.55540c15cf91fp-57 },
};
- static const double cl[3]
+ static const double cl_data[3]
= { -0x1p-3, 0x1.9999999a0754fp-4, -0x1.55555555c3157p-4 };
+ const double *cl = ptr_barrier (cl_data);
uint64_t t = asuint64 (zh);
int ex = t >> 52, e = ex - 0x3ff + (zl == 0.0);
@@ -409,7 +415,7 @@ as_asinh_refine (double x, double zh, double zl, double a)
}
xh = adddd (xh, xl, sh, sl, &xl);
sl = xh * (cl[0] + xh * (cl[1] + xh * cl[2]));
- sh = polydd (xh, xl, 3, ch, &sl);
+ sh = polydd (xh, xl, 3, ptr_barrier (ch), &sl);
sh = muldd_acc (xh, xl, sh, sl, &sl);
sh = adddd (sh, sl, el1, el2, &sl);
sh = adddd (sh, sl, L[1], L[2], &sl);
@@ -78,7 +78,8 @@ as_exp_accurate (double x, double t, double th, double tl, double *l)
double fl = dxh
* (0x1.5555555555555p-5
+ dxh * (0x1.11111113e93e9p-7 + dxh * 0x1.6c16c169400a7p-10));
- double fh = polydd_tanh (dxh, dxl, array_length (ch), ch, &fl);
+ double fh = polydd_tanh (dxh, dxl, array_length (ch), ptr_barrier (ch),
+ &fl);
fh = muldd_acc2 (dxh, dxl, fh, fl, &fl);
fh = muldd_acc2 (th, tl, fh, fl, &fl);
double zh = th + fh, zl = (th - zh) + fh;
@@ -169,8 +170,9 @@ __tanh (double x)
int64_t i1 = (jt >> 27) & 0x3f, i0 = (jt >> 33) & 0x3f,
ie = (int64_t) (jt << 13) >> MANTISSA_WIDTH;
const double sp = asdouble ((uint64_t) (1023 + ie) << MANTISSA_WIDTH);
- static const double ch[]
+ static const double ch_data[]
= { 0x1p+1, 0x1p+1, 0x1.55555557e54ffp+0, 0x1.55555553a12f4p-1 };
+ const double *ch = ptr_barrier (ch_data);
double t0h = T0[i0][1], t1h = T1[i1][1], th = t0h * t1h, tl;
if (aix < UINT64_C(0x400d76c8b4395810))
{ /* |x| ~< 3.683 */
@@ -184,13 +186,14 @@ __tanh (double x)
2^-1022 and rounding towards zero. */
return fma (x, -0x1p-55, x);
}
- static const double c[] =
+ static const double c_data[] =
{
-0x1.5555555555555p-2, 0x1.1111111110f33p-3,
-0x1.ba1ba1b9b8ea6p-5, 0x1.664f4838e0a43p-6,
-0x1.226e17d1bc09bp-7, 0x1.d6c64dfba2565p-9,
-0x1.7bdd094d327afp-10, 0x1.1535ad0c31d0ep-11
};
+ const double *c = ptr_barrier (c_data);
double x2 = x * x, x3 = x2 * x, x4 = x2 * x2, x8 = x4 * x4;
double p1 = (c[4] + x2 * c[5]) + x4 * (c[6] + x2 * c[7]);
double p0 = (c[0] + x2 * c[1]) + x4 * (c[2] + x2 * c[3]);