[PATCH 3/3] math: Use ptr_barrier on the CORE-MATH double tables
Adhemerval Zanella
adhemerval.zanella@linaro.org
Wed Sep 16 16:57:36 GMT 2026
Same as the previous change for the double CORE-MATH implementations,
where constant-indexed local tables are read through a ptr_barrier
pointer.
In lgamma the tables passed to helpers whose low part argument is
known zero are left alone, since the barrier would prevent folding
of the leading term and add work to the dependency chain.
On aarch64 with GCC 15 this removes 325 of the 447 ADRP/LDR literal
loads in the 8 files and about 4% of the instructions; GCC 16 is
within a few instructions of the previous code.
On Neoverse-N1 with gcc 15.2.1, the results with benchtests are:
function geomean
acosh +0.04%
atanh -1.16%
lgamma +0.44%
tgamma -1.06%
sinh +0.39%
asinh -0.03%
tanh +1.08%
summary: 0 improvements, 0 regressions beyond 5%, geomean -0.05% (lower is better)
Checked on aarch64-linux-gnu with gcc-15 and gcc-16 and on
x86_64-linux-gnu.
---
sysdeps/ieee754/dbl-64/e_acosh.c | 22 ++--
sysdeps/ieee754/dbl-64/e_atanh.c | 18 ++--
sysdeps/ieee754/dbl-64/e_cosh.c | 8 +-
sysdeps/ieee754/dbl-64/e_gamma_r.c | 56 ++++++----
sysdeps/ieee754/dbl-64/e_lgamma_r.c | 159 ++++++++++++++++------------
sysdeps/ieee754/dbl-64/e_sinh.c | 14 ++-
sysdeps/ieee754/dbl-64/s_asinh.c | 22 ++--
sysdeps/ieee754/dbl-64/s_tanh.c | 9 +-
8 files changed, 187 insertions(+), 121 deletions(-)
diff --git a/sysdeps/ieee754/dbl-64/e_acosh.c b/sysdeps/ieee754/dbl-64/e_acosh.c
index e2796262e4d..0a652097cb1 100644
--- a/sysdeps/ieee754/dbl-64/e_acosh.c
+++ b/sysdeps/ieee754/dbl-64/e_acosh.c
@@ -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);
diff --git a/sysdeps/ieee754/dbl-64/e_atanh.c b/sysdeps/ieee754/dbl-64/e_atanh.c
index 46821b307b4..a90199e9e79 100644
--- a/sysdeps/ieee754/dbl-64/e_atanh.c
+++ b/sysdeps/ieee754/dbl-64/e_atanh.c
@@ -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;
diff --git a/sysdeps/ieee754/dbl-64/e_cosh.c b/sysdeps/ieee754/dbl-64/e_cosh.c
index b7a35340ce4..73466ccc119 100644
--- a/sysdeps/ieee754/dbl-64/e_cosh.c
+++ b/sysdeps/ieee754/dbl-64/e_cosh.c
@@ -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)))
diff --git a/sysdeps/ieee754/dbl-64/e_gamma_r.c b/sysdeps/ieee754/dbl-64/e_gamma_r.c
index 997c63a7dfe..6580d2062d6 100644
--- a/sysdeps/ieee754/dbl-64/e_gamma_r.c
+++ b/sysdeps/ieee754/dbl-64/e_gamma_r.c
@@ -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;
diff --git a/sysdeps/ieee754/dbl-64/e_lgamma_r.c b/sysdeps/ieee754/dbl-64/e_lgamma_r.c
index aab7b4d1443..627b6e0606f 100644
--- a/sysdeps/ieee754/dbl-64/e_lgamma_r.c
+++ b/sysdeps/ieee754/dbl-64/e_lgamma_r.c
@@ -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]));
diff --git a/sysdeps/ieee754/dbl-64/e_sinh.c b/sysdeps/ieee754/dbl-64/e_sinh.c
index 638e3d6a6d8..433552c871c 100644
--- a/sysdeps/ieee754/dbl-64/e_sinh.c
+++ b/sysdeps/ieee754/dbl-64/e_sinh.c
@@ -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)))
diff --git a/sysdeps/ieee754/dbl-64/s_asinh.c b/sysdeps/ieee754/dbl-64/s_asinh.c
index a15c5a750c7..aa54d772d52 100644
--- a/sysdeps/ieee754/dbl-64/s_asinh.c
+++ b/sysdeps/ieee754/dbl-64/s_asinh.c
@@ -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);
diff --git a/sysdeps/ieee754/dbl-64/s_tanh.c b/sysdeps/ieee754/dbl-64/s_tanh.c
index 2beffdf52a6..38f4a615d80 100644
--- a/sysdeps/ieee754/dbl-64/s_tanh.c
+++ b/sysdeps/ieee754/dbl-64/s_tanh.c
@@ -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]);
--
2.53.0
More information about the Libc-alpha
mailing list