Finalizing asm support for UnixWare, SCO, OpenUnix... Note that I've
[openssl.git] / crypto / bn / bn_mul.c
index ff351af..bfd7f68 100644 (file)
  * [including the GNU Public Licence.]
  */
 
+#ifndef BN_DEBUG
+# undef NDEBUG /* avoid conflicting definitions */
+# define NDEBUG
+#endif
+
 #include <stdio.h>
 #include <assert.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
 
-/* Here follows specialised variants of bn_cmp_words(), bn_add_words() and
-   bn_sub_words().  They all have the property performing operations on
+#if defined(OPENSSL_NO_ASM) || !defined(OPENSSL_BN_ASM_PART_WORDS)
+/* Here follows specialised variants of bn_add_words() and
+   bn_sub_words().  They have the property performing operations on
    arrays of different sizes.  The sizes of those arrays is expressed through
    cl, which is the common length ( basicall, min(len(a),len(b)) ), and dl,
    which is the delta between the two lengths, calculated as len(a)-len(b).
    These functions should probably end up in bn_asm.c as soon as there are
    assembler counterparts for the systems that use assembler files.  */
 
-int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b,
-       int cl, int dl)
-       {
-       if (dl < 0)             /* a < b */
-               return -1;
-       if (dl > 0)             /* a > b */
-               return 1;
-
-       return bn_cmp_words(a,b,cl);
-       }
-
 BN_ULONG bn_sub_part_words(BN_ULONG *r,
        const BN_ULONG *a, const BN_ULONG *b,
        int cl, int dl)
@@ -207,6 +202,7 @@ BN_ULONG bn_sub_part_words(BN_ULONG *r,
                }
        return c;
        }
+#endif
 
 BN_ULONG bn_add_part_words(BN_ULONG *r,
        const BN_ULONG *a, const BN_ULONG *b,
@@ -394,9 +390,10 @@ BN_ULONG bn_add_part_words(BN_ULONG *r,
  * a[1]*b[1]
  */
 void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
-            BN_ULONG *t)
+       int dna, int dnb, BN_ULONG *t)
        {
        int n=n2/2,c1,c2;
+       int tna=n+dna, tnb=n+dnb;
        unsigned int neg,zero;
        BN_ULONG ln,lo,*p;
 
@@ -411,34 +408,40 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
                return;
                }
 #  endif
-       if (n2 == 8)
+       /* Only call bn_mul_comba 8 if n2 == 8 and the
+        * two arrays are complete [steve]
+        */
+       if (n2 == 8 && dna == 0 && dnb == 0)
                {
                bn_mul_comba8(r,a,b);
                return; 
                }
 # endif /* BN_MUL_COMBA */
+       /* Else do normal multiply */
        if (n2 < BN_MUL_RECURSIVE_SIZE_NORMAL)
                {
-               /* This should not happen */
-               bn_mul_normal(r,a,n2,b,n2);
+               bn_mul_normal(r,a,n2+dna,b,n2+dnb);
+               if ((dna + dnb) < 0)
+                       memset(&r[2*n2 + dna + dnb], 0,
+                               sizeof(BN_ULONG) * -(dna + dnb));
                return;
                }
        /* r=(a[0]-a[1])*(b[1]-b[0]) */
-       c1=bn_cmp_words(a,&(a[n]),n);
-       c2=bn_cmp_words(&(b[n]),b,n);
+       c1=bn_cmp_part_words(a,&(a[n]),tna,n-tna);
+       c2=bn_cmp_part_words(&(b[n]),b,tnb,tnb-n);
        zero=neg=0;
        switch (c1*3+c2)
                {
        case -4:
-               bn_sub_words(t,      &(a[n]),a,      n); /* - */
-               bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
+               bn_sub_part_words(t,      &(a[n]),a,      tna,tna-n); /* - */
+               bn_sub_part_words(&(t[n]),b,      &(b[n]),tnb,n-tnb); /* - */
                break;
        case -3:
                zero=1;
                break;
        case -2:
-               bn_sub_words(t,      &(a[n]),a,      n); /* - */
-               bn_sub_words(&(t[n]),&(b[n]),b,      n); /* + */
+               bn_sub_part_words(t,      &(a[n]),a,      tna,tna-n); /* - */
+               bn_sub_part_words(&(t[n]),&(b[n]),b,      tnb,tnb-n); /* + */
                neg=1;
                break;
        case -1:
@@ -447,21 +450,22 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
                zero=1;
                break;
        case 2:
-               bn_sub_words(t,      a,      &(a[n]),n); /* + */
-               bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
+               bn_sub_part_words(t,      a,      &(a[n]),tna,n-tna); /* + */
+               bn_sub_part_words(&(t[n]),b,      &(b[n]),tnb,n-tnb); /* - */
                neg=1;
                break;
        case 3:
                zero=1;
                break;
        case 4:
-               bn_sub_words(t,      a,      &(a[n]),n);
-               bn_sub_words(&(t[n]),&(b[n]),b,      n);
+               bn_sub_part_words(t,      a,      &(a[n]),tna,n-tna);
+               bn_sub_part_words(&(t[n]),&(b[n]),b,      tnb,tnb-n);
                break;
                }
 
 # ifdef BN_MUL_COMBA
-       if (n == 4)
+       if (n == 4 && dna == 0 && dnb == 0) /* XXX: bn_mul_comba4 could take
+                                              extra args to do this well */
                {
                if (!zero)
                        bn_mul_comba4(&(t[n2]),t,&(t[n]));
@@ -471,7 +475,9 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
                bn_mul_comba4(r,a,b);
                bn_mul_comba4(&(r[n2]),&(a[n]),&(b[n]));
                }
-       else if (n == 8)
+       else if (n == 8 && dna == 0 && dnb == 0) /* XXX: bn_mul_comba8 could
+                                                   take extra args to do this
+                                                   well */
                {
                if (!zero)
                        bn_mul_comba8(&(t[n2]),t,&(t[n]));
@@ -486,11 +492,11 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
                {
                p= &(t[n2*2]);
                if (!zero)
-                       bn_mul_recursive(&(t[n2]),t,&(t[n]),n,p);
+                       bn_mul_recursive(&(t[n2]),t,&(t[n]),n,0,0,p);
                else
                        memset(&(t[n2]),0,n2*sizeof(BN_ULONG));
-               bn_mul_recursive(r,a,b,n,p);
-               bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),n,p);
+               bn_mul_recursive(r,a,b,n,0,0,p);
+               bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),n,dna,dnb,p);
                }
 
        /* t[32] holds (a[0]-a[1])*(b[1]-b[0]), c1 is the sign
@@ -539,8 +545,8 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
 
 /* n+tn is the word length
  * t needs to be n*4 is size, as does r */
-void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
-            int n, BN_ULONG *t)
+void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n,
+            int tna, int tnb, BN_ULONG *t)
        {
        int i,j,n2=n*2;
        unsigned int c1,c2,neg,zero;
@@ -548,31 +554,30 @@ void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
 
 # ifdef BN_COUNT
        fprintf(stderr," bn_mul_part_recursive (%d+%d) * (%d+%d)\n",
-               tn, n,tn, n);
+               tna, n, tnb, n);
 # endif
        if (n < 8)
                {
-               i=tn+n;
-               bn_mul_normal(r,a,i,b,i);
+               bn_mul_normal(r,a,n+tna,b,n+tnb);
                return;
                }
 
        /* r=(a[0]-a[1])*(b[1]-b[0]) */
-       c1=bn_cmp_part_words(a,&(a[n]),tn,n-tn);
-       c2=bn_cmp_part_words(&(b[n]),b,tn,tn-n);
+       c1=bn_cmp_part_words(a,&(a[n]),tna,n-tna);
+       c2=bn_cmp_part_words(&(b[n]),b,tnb,tnb-n);
        zero=neg=0;
        switch (c1*3+c2)
                {
        case -4:
-               bn_sub_part_words(t,      &(a[n]),a,      tn,tn-n); /* - */
-               bn_sub_part_words(&(t[n]),b,      &(b[n]),tn,n-tn); /* - */
+               bn_sub_part_words(t,      &(a[n]),a,      tna,tna-n); /* - */
+               bn_sub_part_words(&(t[n]),b,      &(b[n]),tnb,n-tnb); /* - */
                break;
        case -3:
                zero=1;
                /* break; */
        case -2:
-               bn_sub_part_words(t,      &(a[n]),a,      tn,tn-n); /* - */
-               bn_sub_part_words(&(t[n]),&(b[n]),b,      tn,tn-n); /* + */
+               bn_sub_part_words(t,      &(a[n]),a,      tna,tna-n); /* - */
+               bn_sub_part_words(&(t[n]),&(b[n]),b,      tnb,tnb-n); /* + */
                neg=1;
                break;
        case -1:
@@ -581,16 +586,16 @@ void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
                zero=1;
                /* break; */
        case 2:
-               bn_sub_part_words(t,      a,      &(a[n]),tn,n-tn); /* + */
-               bn_sub_part_words(&(t[n]),b,      &(b[n]),tn,n-tn); /* - */
+               bn_sub_part_words(t,      a,      &(a[n]),tna,n-tna); /* + */
+               bn_sub_part_words(&(t[n]),b,      &(b[n]),tnb,n-tnb); /* - */
                neg=1;
                break;
        case 3:
                zero=1;
                /* break; */
        case 4:
-               bn_sub_part_words(t,      a,      &(a[n]),tn,n-tn);
-               bn_sub_part_words(&(t[n]),&(b[n]),b,      tn,tn-n);
+               bn_sub_part_words(t,      a,      &(a[n]),tna,n-tna);
+               bn_sub_part_words(&(t[n]),&(b[n]),b,      tnb,tnb-n);
                break;
                }
                /* The zero case isn't yet implemented here. The speedup
@@ -609,54 +614,59 @@ void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
                {
                bn_mul_comba8(&(t[n2]),t,&(t[n]));
                bn_mul_comba8(r,a,b);
-               bn_mul_normal(&(r[n2]),&(a[n]),tn,&(b[n]),tn);
-               memset(&(r[n2+tn*2]),0,sizeof(BN_ULONG)*(n2-tn*2));
+               bn_mul_normal(&(r[n2]),&(a[n]),tna,&(b[n]),tnb);
+               memset(&(r[n2+tna+tnb]),0,sizeof(BN_ULONG)*(n2-tna-tnb));
                }
        else
                {
                p= &(t[n2*2]);
-               bn_mul_recursive(&(t[n2]),t,&(t[n]),n,p);
-               bn_mul_recursive(r,a,b,n,p);
+               bn_mul_recursive(&(t[n2]),t,&(t[n]),n,0,0,p);
+               bn_mul_recursive(r,a,b,n,0,0,p);
                i=n/2;
                /* If there is only a bottom half to the number,
                 * just do it */
-               j=tn-i;
+               if (tna > tnb)
+                       j = tna - i;
+               else
+                       j = tnb - i;
                if (j == 0)
                        {
-                       bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),i,p);
+                       bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),
+                               i,tna-i,tnb-i,p);
                        memset(&(r[n2+i*2]),0,sizeof(BN_ULONG)*(n2-i*2));
                        }
                else if (j > 0) /* eg, n == 16, i == 8 and tn == 11 */
                                {
                                bn_mul_part_recursive(&(r[n2]),&(a[n]),&(b[n]),
-                                       j,i,p);
-                               memset(&(r[n2+tn*2]),0,
-                                       sizeof(BN_ULONG)*(n2-tn*2));
+                                       i,tna-i,tnb-i,p);
+                               memset(&(r[n2+tna+tnb]),0,
+                                       sizeof(BN_ULONG)*(n2-tna-tnb));
                                }
                else /* (j < 0) eg, n == 16, i == 8 and tn == 5 */
                        {
                        memset(&(r[n2]),0,sizeof(BN_ULONG)*n2);
-                       if (tn < BN_MUL_RECURSIVE_SIZE_NORMAL)
+                       if (tna < BN_MUL_RECURSIVE_SIZE_NORMAL
+                               && tnb < BN_MUL_RECURSIVE_SIZE_NORMAL)
                                {
-                               bn_mul_normal(&(r[n2]),&(a[n]),tn,&(b[n]),tn);
+                               bn_mul_normal(&(r[n2]),&(a[n]),tna,&(b[n]),tnb);
                                }
                        else
                                {
                                for (;;)
                                        {
                                        i/=2;
-                                       if (i < tn)
+                                       if (i < tna && i < tnb)
                                                {
                                                bn_mul_part_recursive(&(r[n2]),
                                                        &(a[n]),&(b[n]),
-                                                       tn-i,i,p);
+                                                       i,tna-i,tnb-i,p);
                                                break;
                                                }
-                                       else if (i == tn)
+                                       else if (i <= tna && i <= tnb)
                                                {
                                                bn_mul_recursive(&(r[n2]),
                                                        &(a[n]),&(b[n]),
-                                                       i,p);
+                                                       i,tna-i,tnb-i,p);
                                                break;
                                                }
                                        }
@@ -720,7 +730,7 @@ void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
        fprintf(stderr," bn_mul_low_recursive %d * %d\n",n2,n2);
 # endif
 
-       bn_mul_recursive(r,a,b,n,&(t[0]));
+       bn_mul_recursive(r,a,b,n,0,0,&(t[0]));
        if (n >= BN_MUL_LOW_RECURSIVE_SIZE_NORMAL)
                {
                bn_mul_low_recursive(&(t[0]),&(a[0]),&(b[n]),n,&(t[n2]));
@@ -804,8 +814,8 @@ void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
        else
 # endif
                {
-               bn_mul_recursive(&(t[0]),&(r[0]),&(r[n]),n,&(t[n2]));
-               bn_mul_recursive(r,&(a[n]),&(b[n]),n,&(t[n2]));
+               bn_mul_recursive(&(t[0]),&(r[0]),&(r[n]),n,0,0,&(t[n2]));
+               bn_mul_recursive(r,&(a[n]),&(b[n]),n,0,0,&(t[n2]));
                }
 
        /* s0 == low(al*bl)
@@ -928,19 +938,18 @@ void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
        }
 #endif /* BN_RECURSION */
 
-int BN_mul(BIGNUM *r, /* almost const */ const BIGNUM *a, /* almost const */ const BIGNUM *b, BN_CTX *ctx)
+int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
        {
+       int ret=0;
        int top,al,bl;
        BIGNUM *rr;
-       int ret = 0;
 #if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
        int i;
 #endif
 #ifdef BN_RECURSION
-       BIGNUM *t;
-       int j,k;
+       BIGNUM *t=NULL;
+       int j=0,k;
 #endif
-       BIGNUM *free_a = NULL, *free_b = NULL;
 
 #ifdef BN_COUNT
        fprintf(stderr,"BN_mul %d * %d\n",a->top,b->top);
@@ -955,7 +964,7 @@ int BN_mul(BIGNUM *r, /* almost const */ const BIGNUM *a, /* almost const */ con
 
        if ((al == 0) || (bl == 0))
                {
-               BN_zero(r);
+               if (!BN_zero(r)) goto err;
                return(1);
                }
        top=al+bl;
@@ -996,10 +1005,46 @@ int BN_mul(BIGNUM *r, /* almost const */ const BIGNUM *a, /* almost const */ con
 #ifdef BN_RECURSION
        if ((al >= BN_MULL_SIZE_NORMAL) && (bl >= BN_MULL_SIZE_NORMAL))
                {
+               if (i >= -1 && i <= 1)
+                       {
+                       int sav_j =0;
+                       /* Find out the power of two lower or equal
+                          to the longest of the two numbers */
+                       if (i >= 0)
+                               {
+                               j = BN_num_bits_word((BN_ULONG)al);
+                               }
+                       if (i == -1)
+                               {
+                               j = BN_num_bits_word((BN_ULONG)bl);
+                               }
+                       sav_j = j;
+                       j = 1<<(j-1);
+                       assert(j <= al || j <= bl);
+                       k = j+j;
+                       t = BN_CTX_get(ctx);
+                       if (al > j || bl > j)
+                               {
+                               bn_wexpand(t,k*4);
+                               bn_wexpand(rr,k*4);
+                               bn_mul_part_recursive(rr->d,a->d,b->d,
+                                       j,al-j,bl-j,t->d);
+                               }
+                       else    /* al <= j || bl <= j */
+                               {
+                               bn_wexpand(t,k*2);
+                               bn_wexpand(rr,k*2);
+                               bn_mul_recursive(rr->d,a->d,b->d,
+                                       j,al-j,bl-j,t->d);
+                               }
+                       rr->top=top;
+                       goto end;
+                       }
+#if 0
                if (i == 1 && !BN_get_flags(b,BN_FLG_STATIC_DATA))
                        {
                        BIGNUM *tmp_bn = (BIGNUM *)b;
-                       bn_wexpand(tmp_bn,al);
+                       if (bn_wexpand(tmp_bn,al) == NULL) goto err;
                        tmp_bn->d[bl]=0;
                        bl++;
                        i--;
@@ -1007,7 +1052,7 @@ int BN_mul(BIGNUM *r, /* almost const */ const BIGNUM *a, /* almost const */ con
                else if (i == -1 && !BN_get_flags(a,BN_FLG_STATIC_DATA))
                        {
                        BIGNUM *tmp_bn = (BIGNUM *)a;
-                       bn_wexpand(tmp_bn,bl);
+                       if (bn_wexpand(tmp_bn,bl) == NULL) goto err;
                        tmp_bn->d[al]=0;
                        al++;
                        i++;
@@ -1022,19 +1067,20 @@ int BN_mul(BIGNUM *r, /* almost const */ const BIGNUM *a, /* almost const */ con
                        t = BN_CTX_get(ctx);
                        if (al == j) /* exact multiple */
                                {
-                               bn_wexpand(t,k*2);
-                               bn_wexpand(rr,k*2);
+                               if (bn_wexpand(t,k*2) == NULL) goto err;
+                               if (bn_wexpand(rr,k*2) == NULL) goto err;
                                bn_mul_recursive(rr->d,a->d,b->d,al,t->d);
                                }
                        else
                                {
-                               bn_wexpand(t,k*4);
-                               bn_wexpand(rr,k*4);
+                               if (bn_wexpand(t,k*4) == NULL) goto err;
+                               if (bn_wexpand(rr,k*4) == NULL) goto err;
                                bn_mul_part_recursive(rr->d,a->d,b->d,al-j,j,t->d);
                                }
                        rr->top=top;
                        goto end;
                        }
+#endif
                }
 #endif /* BN_RECURSION */
        if (bn_wexpand(rr,top) == NULL) goto err;
@@ -1048,8 +1094,6 @@ end:
        if (r != rr) BN_copy(r,rr);
        ret=1;
 err:
-       if (free_a) BN_free(free_a);
-       if (free_b) BN_free(free_b);
        BN_CTX_end(ctx);
        return(ret);
        }
@@ -1072,7 +1116,13 @@ void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
 
                }
        rr= &(r[na]);
-       rr[0]=bn_mul_words(r,a,na,b[0]);
+       if (nb <= 0)
+               {
+               (void)bn_mul_words(r,a,na,0);
+               return;
+               }
+       else
+               rr[0]=bn_mul_words(r,a,na,b[0]);
 
        for (;;)
                {