From bcda8fc69678e9e37cdbf4b4c277e3ed6bb00423 Mon Sep 17 00:00:00 2001
From: Daniel Mendler <mail@daniel-mendler.de>
Date: Tue, 29 Oct 2019 22:38:49 +0100
Subject: [PATCH] simplifications: remove unnecessary optimization

* these double checks are not necessary
* the compiler will move the early return outside of the called
  function, basically the functions is partially inlined
* however lto/amalgamation needed for the optimization
---
 mp_abs.c                      |  9 ++++-----
 mp_add_d.c                    |  9 +++------
 mp_and.c                      |  6 ++----
 mp_copy.c                     |  9 ++++-----
 mp_div_2.c                    |  8 +++-----
 mp_dr_reduce.c                | 10 ++++------
 mp_from_ubin.c                |  6 ++----
 mp_lshd.c                     |  8 +++-----
 mp_montgomery_reduce.c        |  8 +++-----
 mp_mul_2.c                    |  8 +++-----
 mp_mul_2d.c                   | 17 ++++++-----------
 mp_mul_d.c                    |  6 ++----
 mp_neg.c                      |  8 +++-----
 mp_or.c                       |  6 ++----
 mp_sub_d.c                    |  9 +++------
 mp_xor.c                      |  6 ++----
 s_mp_add.c                    |  8 +++-----
 s_mp_montgomery_reduce_fast.c |  6 ++----
 s_mp_mul_digs_fast.c          |  6 ++----
 s_mp_mul_high_digs_fast.c     |  6 ++----
 s_mp_sqr_fast.c               |  8 +++-----
 s_mp_sub.c                    |  8 +++-----
 22 files changed, 64 insertions(+), 111 deletions(-)

diff --git a/mp_abs.c b/mp_abs.c
index 902279e..a87cc0c 100644
--- a/mp_abs.c
+++ b/mp_abs.c
@@ -9,12 +9,11 @@
  */
 mp_err mp_abs(const mp_int *a, mp_int *b)
 {
+   mp_err err;
+
    /* copy a to b */
-   if (a != b) {
-      mp_err err;
-      if ((err = mp_copy(a, b)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_copy(a, b)) != MP_OKAY) {
+      return err;
    }
 
    /* force the sign of b to positive */
diff --git a/mp_add_d.c b/mp_add_d.c
index 9ef4475..de935bb 100644
--- a/mp_add_d.c
+++ b/mp_add_d.c
@@ -6,6 +6,7 @@
 /* single digit addition */
 mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
 {
+   mp_err err;
    int oldused;
 
    /* fast path for a == c */
@@ -24,16 +25,12 @@ mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
    }
 
    /* grow c as required */
-   if (c->alloc < (a->used + 1)) {
-      mp_err err;
-      if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* if a is negative and |a| >= b, call c = |a| - b */
    if ((a->sign == MP_NEG) && ((a->used > 1) || (a->dp[0] >= b))) {
-      mp_err err;
       mp_int a_ = *a;
       /* temporarily fix sign of a */
       a_.sign = MP_ZPOS;
diff --git a/mp_and.c b/mp_and.c
index 92e6aed..a865ae0 100644
--- a/mp_and.c
+++ b/mp_and.c
@@ -11,10 +11,8 @@ mp_err mp_and(const mp_int *a, const mp_int *b, mp_int *c)
    mp_digit ac = 1, bc = 1, cc = 1;
    mp_sign csign = ((a->sign == MP_NEG) && (b->sign == MP_NEG)) ? MP_NEG : MP_ZPOS;
 
-   if (c->alloc < used) {
-      if ((err = mp_grow(c, used)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, used)) != MP_OKAY) {
+      return err;
    }
 
    for (i = 0; i < used; i++) {
diff --git a/mp_copy.c b/mp_copy.c
index cf93b04..d79e2b8 100644
--- a/mp_copy.c
+++ b/mp_copy.c
@@ -6,17 +6,16 @@
 /* copy, b = a */
 mp_err mp_copy(const mp_int *a, mp_int *b)
 {
+   mp_err err;
+
    /* if dst == src do nothing */
    if (a == b) {
       return MP_OKAY;
    }
 
    /* grow dest */
-   if (b->alloc < a->used) {
-      mp_err err;
-      if ((err = mp_grow(b, a->used)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(b, a->used)) != MP_OKAY) {
+      return err;
    }
 
    /* copy everything over and zero high digits */
diff --git a/mp_div_2.c b/mp_div_2.c
index b15391e..8ab9bcb 100644
--- a/mp_div_2.c
+++ b/mp_div_2.c
@@ -6,14 +6,12 @@
 /* b = a/2 */
 mp_err mp_div_2(const mp_int *a, mp_int *b)
 {
+   mp_err err;
    int x, oldused;
    mp_digit r;
 
-   if (b->alloc < a->used) {
-      mp_err err;
-      if ((err = mp_grow(b, a->used)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(b, a->used)) != MP_OKAY) {
+      return err;
    }
 
    oldused = b->used;
diff --git a/mp_dr_reduce.c b/mp_dr_reduce.c
index 1b97a1d..f0f6f35 100644
--- a/mp_dr_reduce.c
+++ b/mp_dr_reduce.c
@@ -19,22 +19,20 @@
  */
 mp_err mp_dr_reduce(mp_int *x, const mp_int *n, mp_digit k)
 {
+   mp_err err;
+
    /* m = digits in modulus */
    int m = n->used;
 
    /* ensure that "x" has at least 2m digits */
-   if (x->alloc < (m + m)) {
-      mp_err err;
-      if ((err = mp_grow(x, m + m)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(x, m + m)) != MP_OKAY) {
+      return err;
    }
 
    /* top of loop, this is where the code resumes if
     * another reduction pass is required.
     */
    for (;;) {
-      mp_err err;
       int i;
       mp_digit mu = 0;
 
diff --git a/mp_from_ubin.c b/mp_from_ubin.c
index ae79be3..8272185 100644
--- a/mp_from_ubin.c
+++ b/mp_from_ubin.c
@@ -9,10 +9,8 @@ mp_err mp_from_ubin(mp_int *a, const uint8_t *buf, size_t size)
    mp_err err;
 
    /* make sure there are at least two digits */
-   if (a->alloc < 2) {
-      if ((err = mp_grow(a, 2)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(a, 2)) != MP_OKAY) {
+      return err;
    }
 
    /* zero the int */
diff --git a/mp_lshd.c b/mp_lshd.c
index 2f56e5d..bfa8af8 100644
--- a/mp_lshd.c
+++ b/mp_lshd.c
@@ -6,6 +6,7 @@
 /* shift left a certain amount of digits */
 mp_err mp_lshd(mp_int *a, int b)
 {
+   mp_err err;
    int x;
 
    /* if its less than zero return */
@@ -18,11 +19,8 @@ mp_err mp_lshd(mp_int *a, int b)
    }
 
    /* grow to fit the new digits */
-   if (a->alloc < (a->used + b)) {
-      mp_err err;
-      if ((err = mp_grow(a, a->used + b)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(a, a->used + b)) != MP_OKAY) {
+      return err;
    }
 
    /* increment the used by the shift amount then copy upwards */
diff --git a/mp_montgomery_reduce.c b/mp_montgomery_reduce.c
index 6a5be26..0a8a1a5 100644
--- a/mp_montgomery_reduce.c
+++ b/mp_montgomery_reduce.c
@@ -6,6 +6,7 @@
 /* computes xR**-1 == x (mod N) via Montgomery Reduction */
 mp_err mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
 {
+   mp_err err;
    int ix, digs;
 
    /* can the fast reduction [comba] method be used?
@@ -22,11 +23,8 @@ mp_err mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
    }
 
    /* grow the input as required */
-   if (x->alloc < digs) {
-      mp_err err;
-      if ((err = mp_grow(x, digs)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(x, digs)) != MP_OKAY) {
+      return err;
    }
    x->used = digs;
 
diff --git a/mp_mul_2.c b/mp_mul_2.c
index 9e549c9..7d7084b 100644
--- a/mp_mul_2.c
+++ b/mp_mul_2.c
@@ -6,15 +6,13 @@
 /* b = a*2 */
 mp_err mp_mul_2(const mp_int *a, mp_int *b)
 {
+   mp_err err;
    int x, oldused;
    mp_digit r;
 
    /* grow to accomodate result */
-   if (b->alloc < (a->used + 1)) {
-      mp_err err;
-      if ((err = mp_grow(b, a->used + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(b, a->used + 1)) != MP_OKAY) {
+      return err;
    }
 
    oldused = b->used;
diff --git a/mp_mul_2d.c b/mp_mul_2d.c
index f1016ea..e458137 100644
--- a/mp_mul_2d.c
+++ b/mp_mul_2d.c
@@ -6,27 +6,22 @@
 /* shift left by a certain bit count */
 mp_err mp_mul_2d(const mp_int *a, int b, mp_int *c)
 {
+   mp_err err;
+
    if (b < 0) {
       return MP_VAL;
    }
 
-   if (a != c) {
-      mp_err err;
-      if ((err = mp_copy(a, c)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_copy(a, c)) != MP_OKAY) {
+      return err;
    }
 
-   if (c->alloc < (c->used + (b / MP_DIGIT_BIT) + 1)) {
-      mp_err err;
-      if ((err = mp_grow(c, c->used + (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, c->used + (b / MP_DIGIT_BIT) + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* shift by as many digits in the bit count */
    if (b >= MP_DIGIT_BIT) {
-      mp_err err;
       if ((err = mp_lshd(c, b / MP_DIGIT_BIT)) != MP_OKAY) {
          return err;
       }
diff --git a/mp_mul_d.c b/mp_mul_d.c
index 2be366f..30d6c93 100644
--- a/mp_mul_d.c
+++ b/mp_mul_d.c
@@ -11,10 +11,8 @@ mp_err mp_mul_d(const mp_int *a, mp_digit b, mp_int *c)
    int   ix, oldused;
 
    /* make sure c is big enough to hold a*b */
-   if (c->alloc < (a->used + 1)) {
-      if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* get the original destinations used count */
diff --git a/mp_neg.c b/mp_neg.c
index f54ef3e..bfb6eb9 100644
--- a/mp_neg.c
+++ b/mp_neg.c
@@ -6,11 +6,9 @@
 /* b = -a */
 mp_err mp_neg(const mp_int *a, mp_int *b)
 {
-   if (a != b) {
-      mp_err err;
-      if ((err = mp_copy(a, b)) != MP_OKAY) {
-         return err;
-      }
+   mp_err err;
+   if ((err = mp_copy(a, b)) != MP_OKAY) {
+      return err;
    }
 
    b->sign = mp_iszero(b) || b->sign == MP_NEG ? MP_ZPOS : MP_NEG;
diff --git a/mp_or.c b/mp_or.c
index 7fa1375..5cf5255 100644
--- a/mp_or.c
+++ b/mp_or.c
@@ -11,10 +11,8 @@ mp_err mp_or(const mp_int *a, const mp_int *b, mp_int *c)
    mp_digit ac = 1, bc = 1, cc = 1;
    mp_sign csign = ((a->sign == MP_NEG) || (b->sign == MP_NEG)) ? MP_NEG : MP_ZPOS;
 
-   if (c->alloc < used) {
-      if ((err = mp_grow(c, used)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, used)) != MP_OKAY) {
+      return err;
    }
 
    for (i = 0; i < used; i++) {
diff --git a/mp_sub_d.c b/mp_sub_d.c
index 91437f8..e80df3d 100644
--- a/mp_sub_d.c
+++ b/mp_sub_d.c
@@ -6,6 +6,7 @@
 /* single digit subtraction */
 mp_err mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
 {
+   mp_err err;
    int oldused;
 
    /* fast path for a == c */
@@ -23,18 +24,14 @@ mp_err mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
    }
 
    /* grow c as required */
-   if (c->alloc < (a->used + 1)) {
-      mp_err err;
-      if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* if a is negative just do an unsigned
     * addition [with fudged signs]
     */
    if (a->sign == MP_NEG) {
-      mp_err err;
       mp_int a_ = *a;
       a_.sign = MP_ZPOS;
       err     = mp_add_d(&a_, b, c);
diff --git a/mp_xor.c b/mp_xor.c
index ca2c2f1..2fe8618 100644
--- a/mp_xor.c
+++ b/mp_xor.c
@@ -11,10 +11,8 @@ mp_err mp_xor(const mp_int *a, const mp_int *b, mp_int *c)
    mp_digit ac = 1, bc = 1, cc = 1;
    mp_sign csign = (a->sign != b->sign) ? MP_NEG : MP_ZPOS;
 
-   if (c->alloc < used) {
-      if ((err = mp_grow(c, used)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, used)) != MP_OKAY) {
+      return err;
    }
 
    for (i = 0; i < used; i++) {
diff --git a/s_mp_add.c b/s_mp_add.c
index 1d799b7..2bda2fe 100644
--- a/s_mp_add.c
+++ b/s_mp_add.c
@@ -8,6 +8,7 @@ mp_err s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
 {
    int oldused, min, max, i;
    mp_digit u;
+   mp_err err;
 
    /* find sizes, we let |a| <= |b| which means we have to sort
     * them.  "x" will point to the input with the most digits
@@ -20,11 +21,8 @@ mp_err s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
    max = a->used;
 
    /* init result */
-   if (c->alloc < (max + 1)) {
-      mp_err err;
-      if ((err = mp_grow(c, max + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, max + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* get old used digit count and set new one */
diff --git a/s_mp_montgomery_reduce_fast.c b/s_mp_montgomery_reduce_fast.c
index 9b08115..751d7fa 100644
--- a/s_mp_montgomery_reduce_fast.c
+++ b/s_mp_montgomery_reduce_fast.c
@@ -25,10 +25,8 @@ mp_err s_mp_montgomery_reduce_fast(mp_int *x, const mp_int *n, mp_digit rho)
    oldused = x->used;
 
    /* grow a as required */
-   if (x->alloc < (n->used + 1)) {
-      if ((err = mp_grow(x, n->used + 1)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(x, n->used + 1)) != MP_OKAY) {
+      return err;
    }
 
    /* first we have to get the digits of the input into
diff --git a/s_mp_mul_digs_fast.c b/s_mp_mul_digs_fast.c
index 3928d04..4f882f1 100644
--- a/s_mp_mul_digs_fast.c
+++ b/s_mp_mul_digs_fast.c
@@ -27,10 +27,8 @@ mp_err s_mp_mul_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int digs)
    mp_word  _W;
 
    /* grow the destination as required */
-   if (c->alloc < digs) {
-      if ((err = mp_grow(c, digs)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, digs)) != MP_OKAY) {
+      return err;
    }
 
    /* number of output digits to produce */
diff --git a/s_mp_mul_high_digs_fast.c b/s_mp_mul_high_digs_fast.c
index 01335a5..36bc69a 100644
--- a/s_mp_mul_high_digs_fast.c
+++ b/s_mp_mul_high_digs_fast.c
@@ -21,10 +21,8 @@ mp_err s_mp_mul_high_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int
 
    /* grow the destination as required */
    pa = a->used + b->used;
-   if (c->alloc < pa) {
-      if ((err = mp_grow(c, pa)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, pa)) != MP_OKAY) {
+      return err;
    }
 
    /* number of output digits to produce */
diff --git a/s_mp_sqr_fast.c b/s_mp_sqr_fast.c
index daf4214..aebc61b 100644
--- a/s_mp_sqr_fast.c
+++ b/s_mp_sqr_fast.c
@@ -18,14 +18,12 @@ mp_err s_mp_sqr_fast(const mp_int *a, mp_int *b)
    int       oldused, pa, ix;
    mp_digit  W[MP_WARRAY];
    mp_word   W1;
+   mp_err err;
 
    /* grow the destination as required */
    pa = a->used + a->used;
-   if (b->alloc < pa) {
-      mp_err err;
-      if ((err = mp_grow(b, pa)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(b, pa)) != MP_OKAY) {
+      return err;
    }
 
    /* number of output digits to produce */
diff --git a/s_mp_sub.c b/s_mp_sub.c
index ead0b51..b1a749e 100644
--- a/s_mp_sub.c
+++ b/s_mp_sub.c
@@ -8,13 +8,11 @@ mp_err s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
 {
    int oldused = c->used, min = b->used, max = a->used, i;
    mp_digit u;
+   mp_err err;
 
    /* init result */
-   if (c->alloc < max) {
-      mp_err err;
-      if ((err = mp_grow(c, max)) != MP_OKAY) {
-         return err;
-      }
+   if ((err = mp_grow(c, max)) != MP_OKAY) {
+      return err;
    }
 
    c->used = max;