add s_mp_floor_ilog2()

instead of all those copies

Signed-off-by: Steffen Jaeckel <[email protected]>

Author: sjaeckel

mp_prime_is_prime.c

@@ -3,16 +3,6 @@
 /* LibTomMath, multiple-precision integer library -- Tom St Denis */
 /* SPDX-License-Identifier: Unlicense */
 
-/* portable integer log of two with small footprint */
-static unsigned int s_floor_ilog2(int value)
-{
-   unsigned int r = 0;
-   while ((value >>= 1) != 0) {
-      r++;
-   }
-   return r;
-}
-
 mp_err mp_prime_is_prime(const mp_int *a, int t, bool *result)
 {
    mp_int  b;
@@ -186,7 +176,7 @@ mp_err mp_prime_is_prime(const mp_int *a, int t, bool *result)
        * Hence the ugly type-fiddling in the following code.
        */
       size_a = mp_count_bits(a);
-      mask = (1u << s_floor_ilog2(size_a)) - 1u;
+      mask = (1u << s_mp_floor_ilog2((unsigned int)size_a)) - 1u;
       /*
          Assuming the General Rieman hypothesis (never thought to write that in a
          comment) the upper bound can be lowered to  2*(log a)^2.

s_mp_faster_read_radix.c

@@ -18,20 +18,11 @@ static const uint8_t s_read_radix_cutoff[65] = { 0, 0,
                                                  18, 17, 17, 17, 17, 17, 17       /* 58 .. 64 */
                                                };
 
-/* This is in mp_prime_is_prime.c and can be reused */
-static int s_floor_ilog2(int value)
-{
-   int r = 0;
-   while ((value >>= 1) != 0) {
-      r++;
-   }
-   return r;
-}
-
 mp_err s_mp_faster_read_radix(mp_int *a, const char *str, size_t start, size_t end, int radix)
 {
    size_t len, mid;
    mp_int A, B, m;
+   mp_digit radix_ = (mp_digit)radix;
    mp_err err = MP_OKAY;
 
    len = end - start;
@@ -42,7 +33,7 @@ mp_err s_mp_faster_read_radix(mp_int *a, const char *str, size_t start, size_t e
 
    mid = len / 2u;
 
-   if ((err = mp_init_set(&m, (mp_digit)radix)) != MP_OKAY) {
+   if ((err = mp_init_set(&m, radix_)) != MP_OKAY) {
       return err;
    }
    if ((err = mp_init_multi(&A, &B, NULL)) != MP_OKAY) {
@@ -53,8 +44,8 @@ mp_err s_mp_faster_read_radix(mp_int *a, const char *str, size_t start, size_t e
    if ((err = s_mp_slower_read_radix(&A, str, start, start + mid + 1, radix)) != MP_OKAY)                goto LTM_ERR;
    if ((err = s_mp_slower_read_radix(&B, str, start + mid +1, end, radix)) != MP_OKAY)                   goto LTM_ERR;
 
-   if (MP_IS_2EXPT((unsigned int)radix)) {
-      if ((err = mp_mul_2d(&A, (int)(((len - mid) - 1u) * (size_t)s_floor_ilog2(radix)), &A)) != MP_OKAY)goto LTM_ERR;
+   if (MP_IS_2EXPT(radix_)) {
+      if ((err = mp_mul_2d(&A, (int)(((len - mid) - 1u) * s_mp_floor_ilog2(radix_)), &A)) != MP_OKAY)    goto LTM_ERR;
    } else {
       if ((err = mp_expt_n(&m, (int)((len - mid) - 1u), &m)) != MP_OKAY)                                 goto LTM_ERR;
       if ((err = mp_mul(&A, &m, &A)) != MP_OKAY)                                                         goto LTM_ERR;

s_mp_floor_ilog2.c

@@ -0,0 +1,15 @@
+#include "tommath_private.h"
+#ifdef S_MP_FLOOR_ILOG2_C
+/* LibTomMath, multiple-precision integer library -- Tom St Denis */
+/* SPDX-License-Identifier: Unlicense */
+
+size_t s_mp_floor_ilog2(mp_word value)
+{
+   size_t r = 0u;
+   while ((value >>= 1) != 0u) {
+      r++;
+   }
+   return r;
+}
+
+#endif

s_mp_fp_log_d.c

@@ -3,22 +3,13 @@
 /* LibTomMath, multiple-precision integer library -- Tom St Denis */
 /* SPDX-License-Identifier: Unlicense */
 
-static mp_word s_mp_flog2_mp_word_d(mp_word value)
-{
-   mp_word r = 0u;
-   while ((value >>= 1) != 0u) {
-      r++;
-   }
-   return r;
-}
-
 /* Fixed point bitwise logarithm base two of "x" with precision "p"  */
 static mp_err s_mp_fp_log_fraction_d(mp_word x, int p, mp_word *c)
 {
    mp_word b, L_out, L, a_bar, twoep;
    int i;
 
-   L = s_mp_flog2_mp_word_d(x);
+   L = s_mp_floor_ilog2(x);
 
    if ((L + (mp_word)p) > MP_UPPER_LIMIT_FIXED_LOG) {
       return MP_VAL;

tommath_private.h

@@ -223,6 +223,7 @@ MP_PRIVATE void s_mp_copy_digs(mp_digit *d, const mp_digit *s, int digits);
 MP_PRIVATE void s_mp_zero_buf(void *mem, size_t size);
 MP_PRIVATE void s_mp_zero_digs(mp_digit *d, int digits);
 MP_PRIVATE mp_err s_mp_radix_size_overestimate(const mp_int *a, const int radix, size_t *size);
+MP_PRIVATE size_t s_mp_floor_ilog2(mp_word value);
 
 #define MP_PRECISION_FIXED_LOG   ( (int) (((sizeof(mp_word) * CHAR_BIT) / 2) - 1))
 #define MP_UPPER_LIMIT_FIXED_LOG ( (int) ( (sizeof(mp_word) * CHAR_BIT) - 1))