Merge pull request #238 from fperrad/20190508_macros

sjaeckel · web-flow · commit be7ee4d02565 · 2019-05-11T16:11:26.000+02:00
new macros
diff --git a/bn_mp_get_long.c b/bn_mp_get_long.c
@@ -14,7 +14,7 @@ unsigned long mp_get_long(const mp_int *a)
    }
 
    /* get number of digits of the lsb we have to read */
-   i = MP_MIN(a->used, (((CHAR_BIT * (int)sizeof(unsigned long)) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;
+   i = MP_MIN(a->used, (((int)MP_SIZEOF_BITS(unsigned long) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;
 
    /* get most significant digit of result */
    res = (unsigned long)a->dp[i];
diff --git a/bn_mp_get_long_long.c b/bn_mp_get_long_long.c
@@ -14,7 +14,7 @@ unsigned long long mp_get_long_long(const mp_int *a)
    }
 
    /* get number of digits of the lsb we have to read */
-   i = MP_MIN(a->used, (((CHAR_BIT * (int)sizeof(unsigned long long)) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;
+   i = MP_MIN(a->used, (((int)MP_SIZEOF_BITS(unsigned long long) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;
 
    /* get most significant digit of result */
    res = (unsigned long long)a->dp[i];
diff --git a/bn_mp_montgomery_reduce.c b/bn_mp_montgomery_reduce.c
@@ -18,8 +18,7 @@ int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
    digs = (n->used * 2) + 1;
    if ((digs < (int)MP_WARRAY) &&
        (x->used <= (int)MP_WARRAY) &&
-       (n->used <
-        (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {
+       (n->used < MP_MAXFAST)) {
       return s_mp_montgomery_reduce_fast(x, n, rho);
    }
 
diff --git a/bn_mp_mul.c b/bn_mp_mul.c
@@ -66,8 +66,7 @@ int mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
 
 #ifdef BN_S_MP_MUL_DIGS_FAST_C
          if ((digs < (int)MP_WARRAY) &&
-             (MP_MIN(a->used, b->used) <=
-              (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {
+             (MP_MIN(a->used, b->used) <= MP_MAXFAST)) {
             res = s_mp_mul_digs_fast(a, b, c, digs);
          } else
 #endif
diff --git a/bn_mp_prime_is_prime.c b/bn_mp_prime_is_prime.c
@@ -287,11 +287,11 @@ int mp_prime_is_prime(const mp_int *a, int t, int *result)
           * One 8-bit digit is too small, so concatenate two if the size of
           * unsigned int allows for it.
           */
-         if (((sizeof(unsigned int) * CHAR_BIT)/2) >= (sizeof(mp_digit) * CHAR_BIT)) {
+         if ((MP_SIZEOF_BITS(unsigned int)/2) >= MP_SIZEOF_BITS(mp_digit)) {
             if ((err = mp_rand(&b, 1)) != MP_OKAY) {
                goto LBL_B;
             }
-            fips_rand <<= CHAR_BIT * sizeof(mp_digit);
+            fips_rand <<= MP_SIZEOF_BITS(mp_digit);
             fips_rand |= (unsigned int) b.dp[0];
             fips_rand &= mask;
          }
diff --git a/bn_mp_sqr.c b/bn_mp_sqr.c
@@ -24,8 +24,7 @@ int mp_sqr(const mp_int *a, mp_int *b)
 #ifdef BN_S_MP_SQR_FAST_C
          /* can we use the fast comba multiplier? */
          if ((((a->used * 2) + 1) < (int)MP_WARRAY) &&
-             (a->used <
-              (int)(1u << (((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT)) - 1u)))) {
+             (a->used < (MP_MAXFAST / 2))) {
             res = s_mp_sqr_fast(a, b);
          } else
 #endif
diff --git a/bn_mp_sub_d.c b/bn_mp_sub_d.c
@@ -55,13 +55,13 @@ int mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
 
       /* subtract first digit */
       *tmpc    = *tmpa++ - b;
-      mu       = *tmpc >> ((CHAR_BIT * sizeof(mp_digit)) - 1u);
+      mu       = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);
       *tmpc++ &= MP_MASK;
 
       /* handle rest of the digits */
       for (ix = 1; ix < a->used; ix++) {
          *tmpc    = *tmpa++ - mu;
-         mu       = *tmpc >> ((CHAR_BIT * sizeof(mp_digit)) - 1u);
+         mu       = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);
          *tmpc++ &= MP_MASK;
       }
    }
diff --git a/bn_s_mp_exptmod_fast.c b/bn_s_mp_exptmod_fast.c
@@ -85,7 +85,7 @@ int s_mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int
       /* automatically pick the comba one if available (saves quite a few calls/ifs) */
 #ifdef BN_S_MP_MONTGOMERY_REDUCE_FAST_C
       if ((((P->used * 2) + 1) < (int)MP_WARRAY) &&
-          (P->used < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * MP_DIGIT_BIT))))) {
+          (P->used < MP_MAXFAST)) {
          redux = s_mp_montgomery_reduce_fast;
       } else
 #endif
diff --git a/bn_s_mp_mul_digs.c b/bn_s_mp_mul_digs.c
@@ -17,8 +17,7 @@ int s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
 
    /* can we use the fast multiplier? */
    if ((digs < (int)MP_WARRAY) &&
-       (MP_MIN(a->used, b->used) <
-        (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {
+       (MP_MIN(a->used, b->used) < MP_MAXFAST)) {
       return s_mp_mul_digs_fast(a, b, c, digs);
    }
 
diff --git a/bn_s_mp_mul_high_digs.c b/bn_s_mp_mul_high_digs.c
@@ -17,7 +17,7 @@ int s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
    /* can we use the fast multiplier? */
 #ifdef BN_S_MP_MUL_HIGH_DIGS_FAST_C
    if (((a->used + b->used + 1) < (int)MP_WARRAY)
-       && (MP_MIN(a->used, b->used) < (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {
+       && (MP_MIN(a->used, b->used) < MP_MAXFAST)) {
       return s_mp_mul_high_digs_fast(a, b, c, digs);
    }
 #endif
diff --git a/bn_s_mp_sub.c b/bn_s_mp_sub.c
@@ -41,7 +41,7 @@ int s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
           * if a carry does occur it will propagate all the way to the
           * MSB.  As a result a single shift is enough to get the carry
           */
-         u = *tmpc >> ((CHAR_BIT * sizeof(mp_digit)) - 1u);
+         u = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);
 
          /* Clear carry from T[i] */
          *tmpc++ &= MP_MASK;
@@ -53,7 +53,7 @@ int s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
          *tmpc = *tmpa++ - u;
 
          /* U = carry bit of T[i] */
-         u = *tmpc >> ((CHAR_BIT * sizeof(mp_digit)) - 1u);
+         u = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);
 
          /* Clear carry from T[i] */
          *tmpc++ &= MP_MASK;
diff --git a/tommath_private.h b/tommath_private.h
@@ -66,6 +66,9 @@ extern void MP_FREE(void *mem, size_t size);
 #define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u))
 #define MP_IS_ODD(a)  (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u))
 
+#define MP_SIZEOF_BITS(type)    (CHAR_BIT * sizeof(type))
+#define MP_MAXFAST              (int)(1u << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT)))
+
 /* random number source */
 extern int (*s_rand_source)(void *, size_t);
 
@@ -104,14 +107,14 @@ extern const size_t mp_s_rmap_reverse_sz;
 int func_name (mp_int * a, type b)                       \
 {                                                        \
    int x = 0;                                            \
-   int new_size = (((CHAR_BIT * sizeof(type)) + MP_DIGIT_BIT) - 1) / MP_DIGIT_BIT; \
+   int new_size = ((MP_SIZEOF_BITS(type) + MP_DIGIT_BIT) - 1) / MP_DIGIT_BIT; \
    int res = mp_grow(a, new_size);                       \
    if (res == MP_OKAY) {                                 \
      mp_zero(a);                                         \
      while (b != 0u) {                                   \
         a->dp[x++] = ((mp_digit)b & MP_MASK);            \
-        if ((CHAR_BIT * sizeof (b)) <= MP_DIGIT_BIT) { break; } \
-        b >>= (((CHAR_BIT * sizeof (b)) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
+        if (MP_SIZEOF_BITS(b) <= MP_DIGIT_BIT) { break; } \
+        b >>= ((MP_SIZEOF_BITS(b) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
      }                                                   \
      a->used = x;                                        \
    }                                                     \

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ unsigned long mp_get_long(const mp_int *a)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`/* get number of digits of the lsb we have to read */`
`17`		`- i = MP_MIN(a->used, (((CHAR_BIT * (int)sizeof(unsigned long)) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;`
	`17`	`+ i = MP_MIN(a->used, (((int)MP_SIZEOF_BITS(unsigned long) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;`
`18`	`18`
`19`	`19`	`/* get most significant digit of result */`
`20`	`20`	`res = (unsigned long)a->dp[i];`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ unsigned long long mp_get_long_long(const mp_int *a)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`/* get number of digits of the lsb we have to read */`
`17`		`- i = MP_MIN(a->used, (((CHAR_BIT * (int)sizeof(unsigned long long)) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;`
	`17`	`+ i = MP_MIN(a->used, (((int)MP_SIZEOF_BITS(unsigned long long) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)) - 1;`
`18`	`18`
`19`	`19`	`/* get most significant digit of result */`
`20`	`20`	`res = (unsigned long long)a->dp[i];`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,7 @@ int mp_montgomery_reduce(mp_int x, const mp_int n, mp_digit rho)`
`18`	`18`	`digs = (n->used * 2) + 1;`
`19`	`19`	`if ((digs < (int)MP_WARRAY) &&`
`20`	`20`	`(x->used <= (int)MP_WARRAY) &&`
`21`		`- (n->used <`
`22`		`- (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {`
	`21`	`+ (n->used < MP_MAXFAST)) {`
`23`	`22`	`return s_mp_montgomery_reduce_fast(x, n, rho);`
`24`	`23`	`}`
`25`	`24`
Original file line number	Diff line number	Diff line change
`@@ -287,11 +287,11 @@ int mp_prime_is_prime(const mp_int a, int t, int result)`
`287`	`287`	`* One 8-bit digit is too small, so concatenate two if the size of`
`288`	`288`	`* unsigned int allows for it.`
`289`	`289`	`*/`
`290`		`- if (((sizeof(unsigned int) * CHAR_BIT)/2) >= (sizeof(mp_digit) * CHAR_BIT)) {`
	`290`	`+ if ((MP_SIZEOF_BITS(unsigned int)/2) >= MP_SIZEOF_BITS(mp_digit)) {`
`291`	`291`	`if ((err = mp_rand(&b, 1)) != MP_OKAY) {`
`292`	`292`	`goto LBL_B;`
`293`	`293`	`}`
`294`		`- fips_rand <<= CHAR_BIT * sizeof(mp_digit);`
	`294`	`+ fips_rand <<= MP_SIZEOF_BITS(mp_digit);`
`295`	`295`	`fips_rand \|= (unsigned int) b.dp[0];`
`296`	`296`	`fips_rand &= mask;`
`297`	`297`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,13 +55,13 @@ int mp_sub_d(const mp_int a, mp_digit b, mp_int c)`
`55`	`55`
`56`	`56`	`/* subtract first digit */`
`57`	`57`	`tmpc = tmpa++ - b;`
`58`		`- mu = tmpc >> ((CHAR_BIT sizeof(mp_digit)) - 1u);`
	`58`	`+ mu = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);`
`59`	`59`	`*tmpc++ &= MP_MASK;`
`60`	`60`
`61`	`61`	`/* handle rest of the digits */`
`62`	`62`	`for (ix = 1; ix < a->used; ix++) {`
`63`	`63`	`tmpc = tmpa++ - mu;`
`64`		`- mu = tmpc >> ((CHAR_BIT sizeof(mp_digit)) - 1u);`
	`64`	`+ mu = *tmpc >> (MP_SIZEOF_BITS(mp_digit) - 1u);`
`65`	`65`	`*tmpc++ &= MP_MASK;`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,7 @@ int s_mp_mul_digs(const mp_int a, const mp_int b, mp_int *c, int digs)`
`17`	`17`
`18`	`18`	`/* can we use the fast multiplier? */`
`19`	`19`	`if ((digs < (int)MP_WARRAY) &&`
`20`		`- (MP_MIN(a->used, b->used) <`
`21`		`- (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {`
	`20`	`+ (MP_MIN(a->used, b->used) < MP_MAXFAST)) {`
`22`	`21`	`return s_mp_mul_digs_fast(a, b, c, digs);`
`23`	`22`	`}`
`24`	`23`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ int s_mp_mul_high_digs(const mp_int a, const mp_int b, mp_int *c, int digs)`
`17`	`17`	`/* can we use the fast multiplier? */`
`18`	`18`	`#ifdef BN_S_MP_MUL_HIGH_DIGS_FAST_C`
`19`	`19`	`if (((a->used + b->used + 1) < (int)MP_WARRAY)`
`20`		`- && (MP_MIN(a->used, b->used) < (int)(1u << ((CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)MP_DIGIT_BIT))))) {`
	`20`	`+ && (MP_MIN(a->used, b->used) < MP_MAXFAST)) {`
`21`	`21`	`return s_mp_mul_high_digs_fast(a, b, c, digs);`
`22`	`22`	`}`
`23`	`23`	`#endif`