Added MPFR_TMP_LIMBS_ALLOC macro and updated the source to use it.

tools/mpfrlint: check its use instead of MPFR_TMP_ALLOC.

git-svn-id: svn://scm.gforge.inria.fr/svn/mpfr/trunk@7300 280ebfd0-de03-0410-8827-d642c229c3f4

19 files changed, 48 insertions, 43 deletions

diff --git a/src/add1.c b/src/add1.c
index 37c910b94..da427b7cf 100644
--- a/src/add1.c
+++ b/src/add1.c
@@ -56,14 +56,14 @@ mpfr_add1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
 
   if (MPFR_UNLIKELY(ap == bp))
     {
-      bp = (mp_ptr) MPFR_TMP_ALLOC (bn * BYTES_PER_MP_LIMB);
+      bp = MPFR_TMP_LIMBS_ALLOC (bn);
       MPN_COPY (bp, ap, bn);
       if (ap == cp)
         { cp = bp; }
     }
   else if (MPFR_UNLIKELY(ap == cp))
     {
-      cp = (mp_ptr) MPFR_TMP_ALLOC (cn * BYTES_PER_MP_LIMB);
+      cp = MPFR_TMP_LIMBS_ALLOC (cn);
       MPN_COPY(cp, ap, cn);
     }
 
diff --git a/src/add1sp.c b/src/add1sp.c
index 49e691c90..bd6eb44de 100644
--- a/src/add1sp.c
+++ b/src/add1sp.c
@@ -204,7 +204,7 @@ mpfr_add1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
       mp_limb_t bcp, bcp1; /* Cp and C'p+1 */
 
       /* General case: 1 <= d < p */
-      cp = (mp_limb_t*) MPFR_TMP_ALLOC(n * BYTES_PER_MP_LIMB);
+      cp = MPFR_TMP_LIMBS_ALLOC (n);
 
       /* Shift c in temporary allocated place */
       {
diff --git a/src/div.c b/src/div.c
index 534511e26..3762b97f1 100644
--- a/src/div.c
+++ b/src/div.c
@@ -264,7 +264,7 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mpfr_rnd_t rnd_mode)
          sticky bits */
       qsize = q0size + 1;
       /* need to allocate memory for the quotient */
-      qp = (mp_ptr) MPFR_TMP_ALLOC (qsize * sizeof(mp_limb_t));
+      qp = MPFR_TMP_LIMBS_ALLOC (qsize);
     }
   else
     {
@@ -274,7 +274,7 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mpfr_rnd_t rnd_mode)
   qqsize = qsize + qsize;
 
   /* prepare the dividend */
-  ap = (mp_ptr) MPFR_TMP_ALLOC (qqsize * sizeof(mp_limb_t));
+  ap = MPFR_TMP_LIMBS_ALLOC (qqsize);
   if (MPFR_LIKELY(qqsize > usize)) /* use the full dividend */
     {
       k = qqsize - usize; /* k > 0 */
@@ -307,7 +307,7 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mpfr_rnd_t rnd_mode)
               between quotient and divisor, necessarily k = 0
               since quotient and divisor are the same mpfr variable */
         {
-          bp = (mp_ptr) MPFR_TMP_ALLOC (qsize * sizeof(mp_limb_t));
+          bp = MPFR_TMP_LIMBS_ALLOC (qsize);
           MPN_COPY(bp, vp, vsize);
         }
       sticky_v = sticky_v || mpfr_mpn_cmpzero (vp, k);
@@ -421,7 +421,7 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mpfr_rnd_t rnd_mode)
               int cmp_s_r;
               mp_limb_t qh2;
 
-              sp = (mp_ptr) MPFR_TMP_ALLOC (vsize * sizeof(mp_limb_t));
+              sp = MPFR_TMP_LIMBS_ALLOC (vsize);
               k = vsize - qsize;
               /* sp <- {qp, qsize} * {vp, vsize-qsize} */
               qp[0] ^= sticky3orig; /* restore original quotient */
diff --git a/src/div_ui.c b/src/div_ui.c
index b7e9a3b7f..a3c2e559a 100644
--- a/src/div_ui.c
+++ b/src/div_ui.c
@@ -93,7 +93,7 @@ mpfr_div_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mpfr_rnd_t rnd_mode
 
   /* we need to store yn+1 = xn + dif limbs of the quotient */
   /* don't use tmp=yp since the mpn_lshift call below requires yp >= tmp+1 */
-  tmp = (mp_limb_t*) MPFR_TMP_ALLOC ((yn + 1) * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (yn + 1);
 
   c = (mp_limb_t) u;
   MPFR_ASSERTN (u == c);
diff --git a/src/get_str.c b/src/get_str.c
index aa7ad18b7..52ace11af 100644
--- a/src/get_str.c
+++ b/src/get_str.c
@@ -2353,7 +2353,7 @@ mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x, mpfr_rnd_t
       n = (prec - 1) / GMP_NUMB_BITS + 1;
 
       MPFR_TMP_MARK (marker);
-      x1 = (mp_limb_t*) MPFR_TMP_ALLOC((n + 1) * sizeof (mp_limb_t));
+      x1 = MPFR_TMP_LIMBS_ALLOC (n + 1);
       nb = n * GMP_NUMB_BITS - prec;
       /* round xp to the precision prec, and put it into x1
          put the carry into x1[n] */
@@ -2419,7 +2419,7 @@ mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x, mpfr_rnd_t
       n = 1 + (prec - 1) / GMP_NUMB_BITS;
 
       /* a will contain the approximation of the mantissa */
-      a = (mp_limb_t*) MPFR_TMP_ALLOC (n * sizeof (mp_limb_t));
+      a = MPFR_TMP_LIMBS_ALLOC (n);
 
       nx = 1 + (MPFR_PREC(x) - 1) / GMP_NUMB_BITS;
 
@@ -2455,7 +2455,7 @@ mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x, mpfr_rnd_t
           err = (err <= 0) ? 2 : err + 1;
 
           /* result = a * x */
-          result = (mp_limb_t*) MPFR_TMP_ALLOC ((n + nx1) * sizeof (mp_limb_t));
+          result = MPFR_TMP_LIMBS_ALLOC (n + nx1);
           mpn_mul (result, a, n, x1, nx1);
           exp_a += MPFR_GET_EXP (x);
           if (mpn_scan1 (result, 0) < (nx1 * GMP_NUMB_BITS))
@@ -2480,9 +2480,9 @@ mpfr_get_str (char *s, mpfr_exp_t *e, int b, size_t m, mpfr_srcptr x, mpfr_rnd_t
           exact = (err == -1);
 
           /* allocate memory for x1, result and reste */
-          x1 = (mp_limb_t*) MPFR_TMP_ALLOC (2 * n * sizeof (mp_limb_t));
-          result = (mp_limb_t*) MPFR_TMP_ALLOC ((n + 1) * sizeof (mp_limb_t));
-          reste = (mp_limb_t*) MPFR_TMP_ALLOC (n * sizeof (mp_limb_t));
+          x1 = MPFR_TMP_LIMBS_ALLOC (2 * n);
+          result = MPFR_TMP_LIMBS_ALLOC (n + 1);
+          reste = MPFR_TMP_LIMBS_ALLOC (n);
 
           /* initialize x1 = x */
           MPN_COPY2 (x1, 2 * n, xp, nx);
diff --git a/src/mpfr-impl.h b/src/mpfr-impl.h
index 4d0a09ecd..4d26d5aa3 100644
--- a/src/mpfr-impl.h
+++ b/src/mpfr-impl.h
@@ -894,6 +894,9 @@ extern unsigned char *mpfr_stack;
 #define MPFR_TMP_FREE(_x) (mpfr_stack = (_x))
 #endif
 
+#define MPFR_TMP_LIMBS_ALLOC(N) \
+  ((mp_limb_t *) MPFR_TMP_ALLOC ((size_t) (N) * BYTES_PER_MP_LIMB))
+
 /* temporary allocate 1 limb at xp, and initialize mpfr variable x */
 /* The temporary var doesn't have any size field, but it doesn't matter
  * since only functions dealing with the Heap care about it */
@@ -904,7 +907,7 @@ extern unsigned char *mpfr_stack;
    MPFR_SET_INVALID_EXP(x))
 
 #define MPFR_TMP_INIT(xp, x, p, s)                                   \
-  (xp = (mp_ptr) MPFR_TMP_ALLOC(BYTES_PER_MP_LIMB * ((size_t) s)),   \
+  (xp = MPFR_TMP_LIMBS_ALLOC(s),                                     \
    MPFR_TMP_INIT1(xp, x, p))
 
 #define MPFR_TMP_INIT_ABS(d, s)                                      \
diff --git a/src/mpn_exp.c b/src/mpn_exp.c
index ea2921feb..1ec3d8c42 100644
--- a/src/mpn_exp.c
+++ b/src/mpn_exp.c
@@ -69,7 +69,7 @@ mpfr_mpn_exp (mp_limb_t *a, mpfr_exp_t *exp_r, int b, mpfr_exp_t e, size_t n)
   h = - h;
 
   /* allocate space for A and set it to B */
-  c = (mp_limb_t*) MPFR_TMP_ALLOC(2 * n * BYTES_PER_MP_LIMB);
+  c = MPFR_TMP_LIMBS_ALLOC (2 * n);
   a [n - 1] = B;
   MPN_ZERO (a, n - 1);
   /* initial exponent for A: invariant is A = {a, n} * 2^f */
diff --git a/src/mul.c b/src/mul.c
index 8d81587c2..7eb866695 100644
--- a/src/mul.c
+++ b/src/mul.c
@@ -108,7 +108,7 @@ mpfr_mul3 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
   /* Check for no size_t overflow*/
   MPFR_ASSERTD((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
   MPFR_TMP_MARK(marker);
-  tmp = (mp_limb_t *) MPFR_TMP_ALLOC((size_t) k * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (k);
 
   /* multiplies two mantissa in temporary allocated space */
   b1 = (MPFR_LIKELY(bn >= cn)) ?
@@ -298,7 +298,7 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
   /* Check for no size_t overflow*/
   MPFR_ASSERTD ((size_t) k <= ((size_t) -1) / BYTES_PER_MP_LIMB);
   MPFR_TMP_MARK (marker);
-  tmp = (mp_limb_t *) MPFR_TMP_ALLOC ((size_t) k * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (k);
 
   /* multiplies two mantissa in temporary allocated space */
   if (MPFR_UNLIKELY (bn < cn))
@@ -436,7 +436,7 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
               bp --;
             else
               {
-                bp = (mp_limb_t*) MPFR_TMP_ALLOC ((n+1) * sizeof (mp_limb_t));
+                bp = MPFR_TMP_LIMBS_ALLOC (n + 1);
                 bp[0] = 0;
                 MPN_COPY (bp + 1, MPFR_MANT (b) + bn - n, n);
               }
@@ -446,7 +446,7 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
                   cp --; /* FIXME: Could this happen? */
                 else
                   {
-                    cp = (mp_limb_t*) MPFR_TMP_ALLOC ((n+1) * sizeof (mp_limb_t));
+                    cp = MPFR_TMP_LIMBS_ALLOC (n + 1);
                     cp[0] = 0;
                     MPN_COPY (cp + 1, MPFR_MANT (c) + cn - n, n);
                   }
@@ -461,7 +461,7 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
 
             if (MPFR_LIKELY (k < 2*n))
               {
-                tmp = (mp_limb_t*) MPFR_TMP_ALLOC (2 * n * sizeof (mp_limb_t));
+                tmp = MPFR_TMP_LIMBS_ALLOC (2 * n);
                 tmp += 2*n-k; /* `tmp' still points to an area of `k' limbs */
               }
           }
diff --git a/src/mul_ui.c b/src/mul_ui.c
index 19cf42f90..cb0d6a650 100644
--- a/src/mul_ui.c
+++ b/src/mul_ui.c
@@ -80,7 +80,7 @@ mpfr_mul_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mpfr_rnd_t rnd_mode
 
   MPFR_ASSERTD (xn < MP_SIZE_T_MAX);
   MPFR_TMP_MARK(marker);
-  yp = (mp_ptr) MPFR_TMP_ALLOC ((size_t) (xn + 1) * BYTES_PER_MP_LIMB);
+  yp = MPFR_TMP_LIMBS_ALLOC (xn + 1);
 
   MPFR_ASSERTN (u == (mp_limb_t) u);
   yp[xn] = mpn_mul_1 (yp, MPFR_MANT (x), xn, u);
diff --git a/src/mulders.c b/src/mulders.c
index c00bb180f..b42530ec3 100644
--- a/src/mulders.c
+++ b/src/mulders.c
@@ -164,7 +164,7 @@ mpfr_divhigh_n (mp_ptr qp, mp_ptr np, mp_ptr dp, mp_size_t n)
   /* it remains {np,2l+k} = {np,n+l} as remainder */
 
   /* now we have to subtract high(Q1)*D0 where Q1={qp+l,k} and D0={dp,l} */
-  tp = (mp_ptr) MPFR_TMP_ALLOC (2 * l * sizeof (mp_limb_t));
+  tp = MPFR_TMP_LIMBS_ALLOC (2 * l);
   mpfr_mulhigh_n (tp, qp + k, dp, l);
   /* we are only interested in the upper l limbs from {tp,2l} */
   cy = mpn_sub_n (np + n, np + n, tp + l, l);
diff --git a/src/rec_sqrt.c b/src/rec_sqrt.c
index 0b5df8b0e..8771e4bb2 100644
--- a/src/rec_sqrt.c
+++ b/src/rec_sqrt.c
@@ -229,7 +229,7 @@ mpfr_mpn_rec_sqrt (mp_ptr x, mpfr_prec_t p,
          2h bits, and th at most h bits, then tn-th can store at least h bits,
          thus tn - th >= xn, and reserving the space for u is enough. */
       MPFR_ASSERTD(2 * xn <= un);
-      u = r = (mp_ptr) MPFR_TMP_ALLOC (un * sizeof (mp_limb_t));
+      u = r = MPFR_TMP_LIMBS_ALLOC (un);
       if (2 * h <= GMP_NUMB_BITS) /* xn=rn=1, and since p <= 2h-3, n=1,
                                      thus ln = 0 */
         {
@@ -253,7 +253,7 @@ mpfr_mpn_rec_sqrt (mp_ptr x, mpfr_prec_t p,
          i.e., at weight 2^{-2h} (s is aligned to the low significant bits)
        */
       sn = an + rn;
-      s = (mp_ptr) MPFR_TMP_ALLOC (sn * sizeof (mp_limb_t));
+      s = MPFR_TMP_LIMBS_ALLOC (sn);
       if (rn == 1) /* rn=1 implies n=1, since rn*GMP_NUMB_BITS >= 2h,
                            and 2h >= p+3 */
         {
@@ -495,7 +495,7 @@ mpfr_rec_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
       wn = LIMB_SIZE(wp);
       out_of_place = (r == u) || (wn > rn);
       if (out_of_place)
-        x = (mp_ptr) MPFR_TMP_ALLOC (wn * sizeof (mp_limb_t));
+        x = MPFR_TMP_LIMBS_ALLOC (wn);
       else
         x = MPFR_MANT(r);
       mpfr_mpn_rec_sqrt (x, wp, MPFR_MANT(u), up, s);
diff --git a/src/round_prec.c b/src/round_prec.c
index d5ac5c93c..755a8261d 100644
--- a/src/round_prec.c
+++ b/src/round_prec.c
@@ -89,7 +89,7 @@ mpfr_prec_round (mpfr_ptr x, mpfr_prec_t prec, mpfr_rnd_t rnd_mode)
   /* x is a non-zero real number */
 
   MPFR_TMP_MARK(marker);
-  tmp = (mp_limb_t*) MPFR_TMP_ALLOC (nw * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (nw);
   xp = MPFR_MANT(x);
   carry = mpfr_round_raw (tmp, xp, MPFR_PREC(x), MPFR_IS_NEG(x),
                           prec, rnd_mode, &inexact);
@@ -184,7 +184,7 @@ mpfr_can_round_raw (const mp_limb_t *bp, mp_size_t bn, int neg, mpfr_exp_t err0,
   MPFR_TMP_MARK(marker);
   tn = bn;
   k++; /* since we work with k+1 everywhere */
-  tmp = (mp_limb_t*) MPFR_TMP_ALLOC(tn * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (tn);
   if (bn > k)
     MPN_COPY (tmp, bp, bn - k);
 
diff --git a/src/set_f.c b/src/set_f.c
index bbd6e5efd..f9df0bb7a 100644
--- a/src/set_f.c
+++ b/src/set_f.c
@@ -54,7 +54,7 @@ mpfr_set_f (mpfr_ptr y, mpf_srcptr x, mpfr_rnd_t rnd_mode)
       unsigned long xprec = sx * GMP_NUMB_BITS;
 
       MPFR_TMP_MARK(marker);
-      tmp = (mp_limb_t*) MPFR_TMP_ALLOC(sx * BYTES_PER_MP_LIMB);
+      tmp = MPFR_TMP_LIMBS_ALLOC (sx);
       if (cnt)
         mpn_lshift (tmp, mx, sx, cnt);
       else
diff --git a/src/sqr.c b/src/sqr.c
index 0db9803e5..59d52933f 100644
--- a/src/sqr.c
+++ b/src/sqr.c
@@ -64,7 +64,7 @@ mpfr_sqr (mpfr_ptr a, mpfr_srcptr b, mpfr_rnd_t rnd_mode)
     return mpfr_mul (a, b, b, rnd_mode);
 
   MPFR_TMP_MARK(marker);
-  tmp = (mp_limb_t *) MPFR_TMP_ALLOC((size_t) 2 * bn * BYTES_PER_MP_LIMB);
+  tmp = MPFR_TMP_LIMBS_ALLOC (2 * bn);
 
   /* Multiplies the mantissa in temporary allocated space */
   mpn_sqr_n (tmp, MPFR_MANT(b), bn);
diff --git a/src/sqrt.c b/src/sqrt.c
index 9a8e1d7b2..928ce51f8 100644
--- a/src/sqrt.c
+++ b/src/sqrt.c
@@ -91,15 +91,14 @@ mpfr_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
   rrsize = rsize + rsize;
   usize = MPFR_LIMB_SIZE(u); /* number of limbs of u */
   rp0 = MPFR_MANT(r);
-  rp = (sh < GMP_NUMB_BITS) ? rp0
-    : (mp_ptr) MPFR_TMP_ALLOC (rsize * sizeof (mp_limb_t));
+  rp = (sh < GMP_NUMB_BITS) ? rp0 : MPFR_TMP_LIMBS_ALLOC (rsize);
   up = MPFR_MANT(u);
   sticky0 = MPFR_LIMB_ZERO; /* truncated part of input */
   sticky1 = MPFR_LIMB_ZERO; /* truncated part of rp[0] */
   odd_exp = (unsigned int) MPFR_GET_EXP (u) & 1;
   inexact = -1; /* return ternary flag */
 
-  sp = (mp_limb_t *) MPFR_TMP_ALLOC (rrsize * sizeof (mp_limb_t));
+  sp = MPFR_TMP_LIMBS_ALLOC (rrsize);
 
   /* copy the most significant limbs of u to {sp, rrsize} */
   if (MPFR_LIKELY(usize <= rrsize)) /* in case r and u have the same precision,
diff --git a/src/strtofr.c b/src/strtofr.c
index 242d24adb..a2c8b4782 100644
--- a/src/strtofr.c
+++ b/src/strtofr.c
@@ -464,7 +464,7 @@ parsed_string_to_mpfr (mpfr_t x, struct parsed_string *pstr, mpfr_rnd_t rnd)
       /* prec bits corresponds to ysize limbs */
       ysize_bits = ysize * GMP_NUMB_BITS;
       /* and to ysize_bits >= prec > MPFR_PREC (x) bits */
-      y = (mp_limb_t*) MPFR_TMP_ALLOC ((2 * ysize + 1) * sizeof (mp_limb_t));
+      y = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 1);
       y += ysize; /* y has (ysize+1) allocated limbs */
 
       /* pstr_size is the number of characters we read in pstr->mant
@@ -586,7 +586,7 @@ parsed_string_to_mpfr (mpfr_t x, struct parsed_string *pstr, mpfr_rnd_t rnd)
           mp_limb_t *z;
           mpfr_exp_t exp_z;
 
-          result = (mp_limb_t*) MPFR_TMP_ALLOC ((2*ysize+1)*BYTES_PER_MP_LIMB);
+          result = MPFR_TMP_LIMBS_ALLOC (2 * ysize + 1);
 
           /* z = base^(exp_base-sptr_size) using space allocated at y-ysize */
           z = y - ysize;
@@ -645,7 +645,7 @@ parsed_string_to_mpfr (mpfr_t x, struct parsed_string *pstr, mpfr_rnd_t rnd)
           mp_limb_t *z;
           mpfr_exp_t exp_z;
 
-          result = (mp_limb_t*) MPFR_TMP_ALLOC ((3*ysize+1) * BYTES_PER_MP_LIMB);
+          result = MPFR_TMP_LIMBS_ALLOC (3 * ysize + 1);
 
           /* set y to y * K^ysize */
           y = y - ysize;  /* we have allocated ysize limbs at y - ysize */
diff --git a/src/sub1.c b/src/sub1.c
index f18023fd5..a858afd3b 100644
--- a/src/sub1.c
+++ b/src/sub1.c
@@ -158,13 +158,13 @@ mpfr_sub1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
       /* Ensure ap != bp */
       if (MPFR_UNLIKELY (ap == bp))
         {
-          bp = (mp_ptr) MPFR_TMP_ALLOC(bn * BYTES_PER_MP_LIMB);
+          bp = MPFR_TMP_LIMBS_ALLOC (bn);
           MPN_COPY (bp, ap, bn);
         }
     }
   else
     {
-      bp = (mp_ptr) MPFR_TMP_ALLOC ((bn + 1) * BYTES_PER_MP_LIMB);
+      bp = MPFR_TMP_LIMBS_ALLOC (bn + 1);
       bp[0] = mpn_rshift (bp + 1, MPFR_MANT(b), bn++, shift_b);
     }
 
@@ -187,13 +187,13 @@ mpfr_sub1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
       /* Ensure ap != cp */
       if (ap == cp)
         {
-          cp = (mp_ptr) MPFR_TMP_ALLOC (cn * BYTES_PER_MP_LIMB);
+          cp = MPFR_TMP_LIMBS_ALLOC (cn);
           MPN_COPY(cp, ap, cn);
         }
     }
  else
     {
-      cp = (mp_ptr) MPFR_TMP_ALLOC ((cn + 1) * BYTES_PER_MP_LIMB);
+      cp = MPFR_TMP_LIMBS_ALLOC (cn + 1);
       cp[0] = mpn_rshift (cp + 1, MPFR_MANT(c), cn++, shift_c);
     }
 
diff --git a/src/sub1sp.c b/src/sub1sp.c
index 728101930..3dd9aaab4 100644
--- a/src/sub1sp.c
+++ b/src/sub1sp.c
@@ -301,7 +301,7 @@ mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
               /* Shift c in the allocated temporary block */
             SubD1NoLose:
               c0 = cp[0] & (MPFR_LIMB_ONE<<sh);
-              cp = (mp_limb_t*) MPFR_TMP_ALLOC(n * BYTES_PER_MP_LIMB);
+              cp = MPFR_TMP_LIMBS_ALLOC (n);
               mpn_rshift(cp, MPFR_MANT(c), n, 1);
               if (MPFR_LIKELY(c0 == 0))
                 {
@@ -346,7 +346,7 @@ mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
               /* Calcul of 2*b-c (Exact) */
               /* Shift b in the allocated temporary block */
             SubD1Lose:
-              bp = (mp_limb_t*) MPFR_TMP_ALLOC (n * BYTES_PER_MP_LIMB);
+              bp = MPFR_TMP_LIMBS_ALLOC (n);
               mpn_lshift (bp, MPFR_MANT(b), n, 1);
               ap = MPFR_MANT(a);
               mpn_sub_n (ap, bp, cp, n);
@@ -497,7 +497,7 @@ mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
 
       /* General case: 2 <= d < p */
       MPFR_UNSIGNED_MINUS_MODULO(sh, p);
-      cp = (mp_limb_t*) MPFR_TMP_ALLOC(n * BYTES_PER_MP_LIMB);
+      cp = MPFR_TMP_LIMBS_ALLOC (n);
 
       /* Shift c in temporary allocated place */
       dm = d % GMP_NUMB_BITS;
diff --git a/tools/mpfrlint b/tools/mpfrlint
index e71e80a3b..c1de5206b 100755
--- a/tools/mpfrlint
+++ b/tools/mpfrlint
@@ -37,6 +37,9 @@ grep "MPFR_LOG_MSG$sp($sp($sp\".*\"$sp)$sp)$sp;" {src,tests}/*.{c,h}
 # This test is a heuristic.
 grep 'MPFR_ASSERTD[^a-z]*;' src/*.c
 
+# Use MPFR_TMP_LIMBS_ALLOC.
+grep 'MPFR_TMP_ALLOC.*\(BYTES_PER_MP_LIMB\|sizeof.*mp_limb_t\)' src/*.c
+
 for file in {src,tests}/*.{c,h} */Makefile.am acinclude.m4 configure.ac
 do
   # Note: this is one less that the POSIX minimum limit in case