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]);
