crypto/bn/bn_asm.c

   1 /* crypto/bn/bn_asm.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include "bn_lcl.h"
  62
  63 #ifdef BN_LLONG
  64
  65 BN_ULONG bn_mul_add_words(rp,ap,num,w)
  66 BN_ULONG *rp,*ap;
  67 int num;
  68 BN_ULONG w;
  69         {
  70         BN_ULONG c1=0;
  71
  72         bn_check_num(num);
  73         if (num <= 0) return(c1);
  74
  75         for (;;)
  76                 {
  77                 mul_add(rp[0],ap[0],w,c1);
  78                 if (--num == 0) break;
  79                 mul_add(rp[1],ap[1],w,c1);
  80                 if (--num == 0) break;
  81                 mul_add(rp[2],ap[2],w,c1);
  82                 if (--num == 0) break;
  83                 mul_add(rp[3],ap[3],w,c1);
  84                 if (--num == 0) break;
  85                 ap+=4;
  86                 rp+=4;
  87                 }
  88
  89         return(c1);
  90         }
  91
  92 BN_ULONG bn_mul_words(rp,ap,num,w)
  93 BN_ULONG *rp,*ap;
  94 int num;
  95 BN_ULONG w;
  96         {
  97         BN_ULONG c1=0;
  98
  99         bn_check_num(num);
 100         if (num <= 0) return(c1);
 101
 102         for (;;)
 103                 {
 104                 mul(rp[0],ap[0],w,c1);
 105                 if (--num == 0) break;
 106                 mul(rp[1],ap[1],w,c1);
 107                 if (--num == 0) break;
 108                 mul(rp[2],ap[2],w,c1);
 109                 if (--num == 0) break;
 110                 mul(rp[3],ap[3],w,c1);
 111                 if (--num == 0) break;
 112                 ap+=4;
 113                 rp+=4;
 114                 }
 115         return(c1);
 116         }
 117
 118 void bn_sqr_words(r,a,n)
 119 BN_ULONG *r,*a;
 120 int n;
 121         {
 122         bn_check_num(n);
 123         if (n <= 0) return;
 124         for (;;)
 125                 {
 126                 BN_ULLONG t;
 127
 128                 t=(BN_ULLONG)(a[0])*(a[0]);
 129                 r[0]=Lw(t); r[1]=Hw(t);
 130                 if (--n == 0) break;
 131
 132                 t=(BN_ULLONG)(a[1])*(a[1]);
 133                 r[2]=Lw(t); r[3]=Hw(t);
 134                 if (--n == 0) break;
 135
 136                 t=(BN_ULLONG)(a[2])*(a[2]);
 137                 r[4]=Lw(t); r[5]=Hw(t);
 138                 if (--n == 0) break;
 139
 140                 t=(BN_ULLONG)(a[3])*(a[3]);
 141                 r[6]=Lw(t); r[7]=Hw(t);
 142                 if (--n == 0) break;
 143
 144                 a+=4;
 145                 r+=8;
 146                 }
 147         }
 148
 149 #else
 150
 151 BN_ULONG bn_mul_add_words(rp,ap,num,w)
 152 BN_ULONG *rp,*ap;
 153 int num;
 154 BN_ULONG w;
 155         {
 156         BN_ULONG c=0;
 157         BN_ULONG bl,bh;
 158
 159         bn_check_num(num);
 160         if (num <= 0) return((BN_ULONG)0);
 161
 162         bl=LBITS(w);
 163         bh=HBITS(w);
 164
 165         for (;;)
 166                 {
 167                 mul_add(rp[0],ap[0],bl,bh,c);
 168                 if (--num == 0) break;
 169                 mul_add(rp[1],ap[1],bl,bh,c);
 170                 if (--num == 0) break;
 171                 mul_add(rp[2],ap[2],bl,bh,c);
 172                 if (--num == 0) break;
 173                 mul_add(rp[3],ap[3],bl,bh,c);
 174                 if (--num == 0) break;
 175                 ap+=4;
 176                 rp+=4;
 177                 }
 178         return(c);
 179         }
 180
 181 BN_ULONG bn_mul_words(rp,ap,num,w)
 182 BN_ULONG *rp,*ap;
 183 int num;
 184 BN_ULONG w;
 185         {
 186         BN_ULONG carry=0;
 187         BN_ULONG bl,bh;
 188
 189         bn_check_num(num);
 190         if (num <= 0) return((BN_ULONG)0);
 191
 192         bl=LBITS(w);
 193         bh=HBITS(w);
 194
 195         for (;;)
 196                 {
 197                 mul(rp[0],ap[0],bl,bh,carry);
 198                 if (--num == 0) break;
 199                 mul(rp[1],ap[1],bl,bh,carry);
 200                 if (--num == 0) break;
 201                 mul(rp[2],ap[2],bl,bh,carry);
 202                 if (--num == 0) break;
 203                 mul(rp[3],ap[3],bl,bh,carry);
 204                 if (--num == 0) break;
 205                 ap+=4;
 206                 rp+=4;
 207                 }
 208         return(carry);
 209         }
 210
 211 void bn_sqr_words(r,a,n)
 212 BN_ULONG *r,*a;
 213 int n;
 214         {
 215         bn_check_num(n);
 216         if (n <= 0) return;
 217         for (;;)
 218                 {
 219                 sqr64(r[0],r[1],a[0]);
 220                 if (--n == 0) break;
 221
 222                 sqr64(r[2],r[3],a[1]);
 223                 if (--n == 0) break;
 224
 225                 sqr64(r[4],r[5],a[2]);
 226                 if (--n == 0) break;
 227
 228                 sqr64(r[6],r[7],a[3]);
 229                 if (--n == 0) break;
 230
 231                 a+=4;
 232                 r+=8;
 233                 }
 234         }
 235
 236 #endif
 237
 238 #if defined(BN_LLONG) && defined(BN_DIV2W)
 239
 240 BN_ULONG bn_div_words(h,l,d)
 241 BN_ULONG h,l,d;
 242         {
 243         return((BN_ULONG)(((((BN_ULLONG)h)<<BN_BITS2)|l)/(BN_ULLONG)d));
 244         }
 245
 246 #else
 247
 248 /* Divide h-l by d and return the result. */
 249 /* I need to test this some more :-( */
 250 BN_ULONG bn_div_words(h,l,d)
 251 BN_ULONG h,l,d;
 252         {
 253         BN_ULONG dh,dl,q,ret=0,th,tl,t;
 254         int i,count=2;
 255
 256         if (d == 0) return(BN_MASK2);
 257
 258         i=BN_num_bits_word(d);
 259         if ((i != BN_BITS2) && (h > (BN_ULONG)1<<i))
 260                 {
 261 #if !defined(NO_STDIO) && !defined(WIN16)
 262                 fprintf(stderr,"Division would overflow (%d)\n",i);
 263 #endif
 264                 abort();
 265                 }
 266         i=BN_BITS2-i;
 267         if (h >= d) h-=d;
 268
 269         if (i)
 270                 {
 271                 d<<=i;
 272                 h=(h<<i)|(l>>(BN_BITS2-i));
 273                 l<<=i;
 274                 }
 275         dh=(d&BN_MASK2h)>>BN_BITS4;
 276         dl=(d&BN_MASK2l);
 277         for (;;)
 278                 {
 279                 if ((h>>BN_BITS4) == dh)
 280                         q=BN_MASK2l;
 281                 else
 282                         q=h/dh;
 283
 284                 for (;;)
 285                         {
 286                         t=(h-q*dh);
 287                         if ((t&BN_MASK2h) ||
 288                                 ((dl*q) <= (
 289                                         (t<<BN_BITS4)+
 290                                         ((l&BN_MASK2h)>>BN_BITS4))))
 291                                 break;
 292                         q--;
 293                         }
 294                 th=q*dh;
 295                 tl=q*dl;
 296                 t=(tl>>BN_BITS4);
 297                 tl=(tl<<BN_BITS4)&BN_MASK2h;
 298                 th+=t;
 299
 300                 if (l < tl) th++;
 301                 l-=tl;
 302                 if (h < th)
 303                         {
 304                         h+=d;
 305                         q--;
 306                         }
 307                 h-=th;
 308
 309                 if (--count == 0) break;
 310
 311                 ret=q<<BN_BITS4;
 312                 h=((h<<BN_BITS4)|(l>>BN_BITS4))&BN_MASK2;
 313                 l=(l&BN_MASK2l)<<BN_BITS4;
 314                 }
 315         ret|=q;
 316         return(ret);
 317         }
 318 #endif
 319
 320 #ifdef BN_LLONG
 321 BN_ULONG bn_add_words(r,a,b,n)
 322 BN_ULONG *r,*a,*b;
 323 int n;
 324         {
 325         BN_ULLONG ll=0;
 326
 327         bn_check_num(n);
 328         if (n <= 0) return((BN_ULONG)0);
 329
 330         for (;;)
 331                 {
 332                 ll+=(BN_ULLONG)a[0]+b[0];
 333                 r[0]=(BN_ULONG)ll&BN_MASK2;
 334                 ll>>=BN_BITS2;
 335                 if (--n <= 0) break;
 336
 337                 ll+=(BN_ULLONG)a[1]+b[1];
 338                 r[1]=(BN_ULONG)ll&BN_MASK2;
 339                 ll>>=BN_BITS2;
 340                 if (--n <= 0) break;
 341
 342                 ll+=(BN_ULLONG)a[2]+b[2];
 343                 r[2]=(BN_ULONG)ll&BN_MASK2;
 344                 ll>>=BN_BITS2;
 345                 if (--n <= 0) break;
 346
 347                 ll+=(BN_ULLONG)a[3]+b[3];
 348                 r[3]=(BN_ULONG)ll&BN_MASK2;
 349                 ll>>=BN_BITS2;
 350                 if (--n <= 0) break;
 351
 352                 a+=4;
 353                 b+=4;
 354                 r+=4;
 355                 }
 356         return((BN_ULONG)ll);
 357         }
 358 #else
 359 BN_ULONG bn_add_words(r,a,b,n)
 360 BN_ULONG *r,*a,*b;
 361 int n;
 362         {
 363         BN_ULONG c,l,t;
 364
 365         bn_check_num(n);
 366         if (n <= 0) return((BN_ULONG)0);
 367
 368         c=0;
 369         for (;;)
 370                 {
 371                 t=a[0];
 372                 t=(t+c)&BN_MASK2;
 373                 c=(t < c);
 374                 l=(t+b[0])&BN_MASK2;
 375                 c+=(l < t);
 376                 r[0]=l;
 377                 if (--n <= 0) break;
 378
 379                 t=a[1];
 380                 t=(t+c)&BN_MASK2;
 381                 c=(t < c);
 382                 l=(t+b[1])&BN_MASK2;
 383                 c+=(l < t);
 384                 r[1]=l;
 385                 if (--n <= 0) break;
 386
 387                 t=a[2];
 388                 t=(t+c)&BN_MASK2;
 389                 c=(t < c);
 390                 l=(t+b[2])&BN_MASK2;
 391                 c+=(l < t);
 392                 r[2]=l;
 393                 if (--n <= 0) break;
 394
 395                 t=a[3];
 396                 t=(t+c)&BN_MASK2;
 397                 c=(t < c);
 398                 l=(t+b[3])&BN_MASK2;
 399                 c+=(l < t);
 400                 r[3]=l;
 401                 if (--n <= 0) break;
 402
 403                 a+=4;
 404                 b+=4;
 405                 r+=4;
 406                 }
 407         return((BN_ULONG)c);
 408         }
 409 #endif
 410
 411 BN_ULONG bn_sub_words(r,a,b,n)
 412 BN_ULONG *r,*a,*b;
 413 int n;
 414         {
 415         BN_ULONG t1,t2;
 416         int c=0;
 417
 418         bn_check_num(n);
 419         if (n <= 0) return((BN_ULONG)0);
 420
 421         for (;;)
 422                 {
 423                 t1=a[0]; t2=b[0];
 424                 r[0]=(t1-t2-c)&BN_MASK2;
 425                 if (t1 != t2) c=(t1 < t2);
 426                 if (--n <= 0) break;
 427
 428                 t1=a[1]; t2=b[1];
 429                 r[1]=(t1-t2-c)&BN_MASK2;
 430                 if (t1 != t2) c=(t1 < t2);
 431                 if (--n <= 0) break;
 432
 433                 t1=a[2]; t2=b[2];
 434                 r[2]=(t1-t2-c)&BN_MASK2;
 435                 if (t1 != t2) c=(t1 < t2);
 436                 if (--n <= 0) break;
 437
 438                 t1=a[3]; t2=b[3];
 439                 r[3]=(t1-t2-c)&BN_MASK2;
 440                 if (t1 != t2) c=(t1 < t2);
 441                 if (--n <= 0) break;
 442
 443                 a+=4;
 444                 b+=4;
 445                 r+=4;
 446                 }
 447         return(c);
 448         }
 449
 450 #ifdef BN_COMBA
 451
 452 #undef bn_mul_comba8
 453 #undef bn_mul_comba4
 454 #undef bn_sqr_comba8
 455 #undef bn_sqr_comba4
 456
 457 #ifdef BN_LLONG
 458 #define mul_add_c(a,b,c0,c1,c2) \
 459         t=(BN_ULLONG)a*b; \
 460         t1=(BN_ULONG)Lw(t); \
 461         t2=(BN_ULONG)Hw(t); \
 462         c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
 463         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 464
 465 #define mul_add_c2(a,b,c0,c1,c2) \
 466         t=(BN_ULLONG)a*b; \
 467         tt=(t+t)&BN_MASK; \
 468         if (tt < t) c2++; \
 469         t1=(BN_ULONG)Lw(tt); \
 470         t2=(BN_ULONG)Hw(tt); \
 471         c0=(c0+t1)&BN_MASK2;  \
 472         if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \
 473         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 474
 475 #define sqr_add_c(a,i,c0,c1,c2) \
 476         t=(BN_ULLONG)a[i]*a[i]; \
 477         t1=(BN_ULONG)Lw(t); \
 478         t2=(BN_ULONG)Hw(t); \
 479         c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
 480         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 481
 482 #define sqr_add_c2(a,i,j,c0,c1,c2) \
 483         mul_add_c2((a)[i],(a)[j],c0,c1,c2)
 484 #else
 485 #define mul_add_c(a,b,c0,c1,c2) \
 486         t1=LBITS(a); t2=HBITS(a); \
 487         bl=LBITS(b); bh=HBITS(b); \
 488         mul64(t1,t2,bl,bh); \
 489         c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
 490         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 491
 492 #define mul_add_c2(a,b,c0,c1,c2) \
 493         t1=LBITS(a); t2=HBITS(a); \
 494         bl=LBITS(b); bh=HBITS(b); \
 495         mul64(t1,t2,bl,bh); \
 496         if (t2 & BN_TBIT) c2++; \
 497         t2=(t2+t2)&BN_MASK2; \
 498         if (t1 & BN_TBIT) t2++; \
 499         t1=(t1+t1)&BN_MASK2; \
 500         c0=(c0+t1)&BN_MASK2;  \
 501         if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \
 502         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 503
 504 #define sqr_add_c(a,i,c0,c1,c2) \
 505         sqr64(t1,t2,(a)[i]); \
 506         c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
 507         c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
 508
 509 #define sqr_add_c2(a,i,j,c0,c1,c2) \
 510         mul_add_c2((a)[i],(a)[j],c0,c1,c2)
 511 #endif
 512
 513 void bn_mul_comba8(r,a,b)
 514 BN_ULONG *r,*a,*b;
 515         {
 516 #ifdef BN_LLONG
 517         BN_ULLONG t;
 518 #else
 519         BN_ULONG bl,bh;
 520 #endif
 521         BN_ULONG t1,t2;
 522         BN_ULONG c1,c2,c3;
 523
 524         c1=0;
 525         c2=0;
 526         c3=0;
 527         mul_add_c(a[0],b[0],c1,c2,c3);
 528         r[0]=c1;
 529         c1=0;
 530         mul_add_c(a[0],b[1],c2,c3,c1);
 531         mul_add_c(a[1],b[0],c2,c3,c1);
 532         r[1]=c2;
 533         c2=0;
 534         mul_add_c(a[2],b[0],c3,c1,c2);
 535         mul_add_c(a[1],b[1],c3,c1,c2);
 536         mul_add_c(a[0],b[2],c3,c1,c2);
 537         r[2]=c3;
 538         c3=0;
 539         mul_add_c(a[0],b[3],c1,c2,c3);
 540         mul_add_c(a[1],b[2],c1,c2,c3);
 541         mul_add_c(a[2],b[1],c1,c2,c3);
 542         mul_add_c(a[3],b[0],c1,c2,c3);
 543         r[3]=c1;
 544         c1=0;
 545         mul_add_c(a[4],b[0],c2,c3,c1);
 546         mul_add_c(a[3],b[1],c2,c3,c1);
 547         mul_add_c(a[2],b[2],c2,c3,c1);
 548         mul_add_c(a[1],b[3],c2,c3,c1);
 549         mul_add_c(a[0],b[4],c2,c3,c1);
 550         r[4]=c2;
 551         c2=0;
 552         mul_add_c(a[0],b[5],c3,c1,c2);
 553         mul_add_c(a[1],b[4],c3,c1,c2);
 554         mul_add_c(a[2],b[3],c3,c1,c2);
 555         mul_add_c(a[3],b[2],c3,c1,c2);
 556         mul_add_c(a[4],b[1],c3,c1,c2);
 557         mul_add_c(a[5],b[0],c3,c1,c2);
 558         r[5]=c3;
 559         c3=0;
 560         mul_add_c(a[6],b[0],c1,c2,c3);
 561         mul_add_c(a[5],b[1],c1,c2,c3);
 562         mul_add_c(a[4],b[2],c1,c2,c3);
 563         mul_add_c(a[3],b[3],c1,c2,c3);
 564         mul_add_c(a[2],b[4],c1,c2,c3);
 565         mul_add_c(a[1],b[5],c1,c2,c3);
 566         mul_add_c(a[0],b[6],c1,c2,c3);
 567         r[6]=c1;
 568         c1=0;
 569         mul_add_c(a[0],b[7],c2,c3,c1);
 570         mul_add_c(a[1],b[6],c2,c3,c1);
 571         mul_add_c(a[2],b[5],c2,c3,c1);
 572         mul_add_c(a[3],b[4],c2,c3,c1);
 573         mul_add_c(a[4],b[3],c2,c3,c1);
 574         mul_add_c(a[5],b[2],c2,c3,c1);
 575         mul_add_c(a[6],b[1],c2,c3,c1);
 576         mul_add_c(a[7],b[0],c2,c3,c1);
 577         r[7]=c2;
 578         c2=0;
 579         mul_add_c(a[7],b[1],c3,c1,c2);
 580         mul_add_c(a[6],b[2],c3,c1,c2);
 581         mul_add_c(a[5],b[3],c3,c1,c2);
 582         mul_add_c(a[4],b[4],c3,c1,c2);
 583         mul_add_c(a[3],b[5],c3,c1,c2);
 584         mul_add_c(a[2],b[6],c3,c1,c2);
 585         mul_add_c(a[1],b[7],c3,c1,c2);
 586         r[8]=c3;
 587         c3=0;
 588         mul_add_c(a[2],b[7],c1,c2,c3);
 589         mul_add_c(a[3],b[6],c1,c2,c3);
 590         mul_add_c(a[4],b[5],c1,c2,c3);
 591         mul_add_c(a[5],b[4],c1,c2,c3);
 592         mul_add_c(a[6],b[3],c1,c2,c3);
 593         mul_add_c(a[7],b[2],c1,c2,c3);
 594         r[9]=c1;
 595         c1=0;
 596         mul_add_c(a[7],b[3],c2,c3,c1);
 597         mul_add_c(a[6],b[4],c2,c3,c1);
 598         mul_add_c(a[5],b[5],c2,c3,c1);
 599         mul_add_c(a[4],b[6],c2,c3,c1);
 600         mul_add_c(a[3],b[7],c2,c3,c1);
 601         r[10]=c2;
 602         c2=0;
 603         mul_add_c(a[4],b[7],c3,c1,c2);
 604         mul_add_c(a[5],b[6],c3,c1,c2);
 605         mul_add_c(a[6],b[5],c3,c1,c2);
 606         mul_add_c(a[7],b[4],c3,c1,c2);
 607         r[11]=c3;
 608         c3=0;
 609         mul_add_c(a[7],b[5],c1,c2,c3);
 610         mul_add_c(a[6],b[6],c1,c2,c3);
 611         mul_add_c(a[5],b[7],c1,c2,c3);
 612         r[12]=c1;
 613         c1=0;
 614         mul_add_c(a[6],b[7],c2,c3,c1);
 615         mul_add_c(a[7],b[6],c2,c3,c1);
 616         r[13]=c2;
 617         c2=0;
 618         mul_add_c(a[7],b[7],c3,c1,c2);
 619         r[14]=c3;
 620         r[15]=c1;
 621         }
 622
 623 void bn_mul_comba4(r,a,b)
 624 BN_ULONG *r,*a,*b;
 625         {
 626 #ifdef BN_LLONG
 627         BN_ULLONG t;
 628 #else
 629         BN_ULONG bl,bh;
 630 #endif
 631         BN_ULONG t1,t2;
 632         BN_ULONG c1,c2,c3;
 633
 634         c1=0;
 635         c2=0;
 636         c3=0;
 637         mul_add_c(a[0],b[0],c1,c2,c3);
 638         r[0]=c1;
 639         c1=0;
 640         mul_add_c(a[0],b[1],c2,c3,c1);
 641         mul_add_c(a[1],b[0],c2,c3,c1);
 642         r[1]=c2;
 643         c2=0;
 644         mul_add_c(a[2],b[0],c3,c1,c2);
 645         mul_add_c(a[1],b[1],c3,c1,c2);
 646         mul_add_c(a[0],b[2],c3,c1,c2);
 647         r[2]=c3;
 648         c3=0;
 649         mul_add_c(a[0],b[3],c1,c2,c3);
 650         mul_add_c(a[1],b[2],c1,c2,c3);
 651         mul_add_c(a[2],b[1],c1,c2,c3);
 652         mul_add_c(a[3],b[0],c1,c2,c3);
 653         r[3]=c1;
 654         c1=0;
 655         mul_add_c(a[3],b[1],c2,c3,c1);
 656         mul_add_c(a[2],b[2],c2,c3,c1);
 657         mul_add_c(a[1],b[3],c2,c3,c1);
 658         r[4]=c2;
 659         c2=0;
 660         mul_add_c(a[2],b[3],c3,c1,c2);
 661         mul_add_c(a[3],b[2],c3,c1,c2);
 662         r[5]=c3;
 663         c3=0;
 664         mul_add_c(a[3],b[3],c1,c2,c3);
 665         r[6]=c1;
 666         r[7]=c2;
 667         }
 668
 669 void bn_sqr_comba8(r,a)
 670 BN_ULONG *r,*a;
 671         {
 672 #ifdef BN_LLONG
 673         BN_ULLONG t,tt;
 674 #else
 675         BN_ULONG bl,bh;
 676 #endif
 677         BN_ULONG t1,t2;
 678         BN_ULONG c1,c2,c3;
 679
 680         c1=0;
 681         c2=0;
 682         c3=0;
 683         sqr_add_c(a,0,c1,c2,c3);
 684         r[0]=c1;
 685         c1=0;
 686         sqr_add_c2(a,1,0,c2,c3,c1);
 687         r[1]=c2;
 688         c2=0;
 689         sqr_add_c(a,1,c3,c1,c2);
 690         sqr_add_c2(a,2,0,c3,c1,c2);
 691         r[2]=c3;
 692         c3=0;
 693         sqr_add_c2(a,3,0,c1,c2,c3);
 694         sqr_add_c2(a,2,1,c1,c2,c3);
 695         r[3]=c1;
 696         c1=0;
 697         sqr_add_c(a,2,c2,c3,c1);
 698         sqr_add_c2(a,3,1,c2,c3,c1);
 699         sqr_add_c2(a,4,0,c2,c3,c1);
 700         r[4]=c2;
 701         c2=0;
 702         sqr_add_c2(a,5,0,c3,c1,c2);
 703         sqr_add_c2(a,4,1,c3,c1,c2);
 704         sqr_add_c2(a,3,2,c3,c1,c2);
 705         r[5]=c3;
 706         c3=0;
 707         sqr_add_c(a,3,c1,c2,c3);
 708         sqr_add_c2(a,4,2,c1,c2,c3);
 709         sqr_add_c2(a,5,1,c1,c2,c3);
 710         sqr_add_c2(a,6,0,c1,c2,c3);
 711         r[6]=c1;
 712         c1=0;
 713         sqr_add_c2(a,7,0,c2,c3,c1);
 714         sqr_add_c2(a,6,1,c2,c3,c1);
 715         sqr_add_c2(a,5,2,c2,c3,c1);
 716         sqr_add_c2(a,4,3,c2,c3,c1);
 717         r[7]=c2;
 718         c2=0;
 719         sqr_add_c(a,4,c3,c1,c2);
 720         sqr_add_c2(a,5,3,c3,c1,c2);
 721         sqr_add_c2(a,6,2,c3,c1,c2);
 722         sqr_add_c2(a,7,1,c3,c1,c2);
 723         r[8]=c3;
 724         c3=0;
 725         sqr_add_c2(a,7,2,c1,c2,c3);
 726         sqr_add_c2(a,6,3,c1,c2,c3);
 727         sqr_add_c2(a,5,4,c1,c2,c3);
 728         r[9]=c1;
 729         c1=0;
 730         sqr_add_c(a,5,c2,c3,c1);
 731         sqr_add_c2(a,6,4,c2,c3,c1);
 732         sqr_add_c2(a,7,3,c2,c3,c1);
 733         r[10]=c2;
 734         c2=0;
 735         sqr_add_c2(a,7,4,c3,c1,c2);
 736         sqr_add_c2(a,6,5,c3,c1,c2);
 737         r[11]=c3;
 738         c3=0;
 739         sqr_add_c(a,6,c1,c2,c3);
 740         sqr_add_c2(a,7,5,c1,c2,c3);
 741         r[12]=c1;
 742         c1=0;
 743         sqr_add_c2(a,7,6,c2,c3,c1);
 744         r[13]=c2;
 745         c2=0;
 746         sqr_add_c(a,7,c3,c1,c2);
 747         r[14]=c3;
 748         r[15]=c1;
 749         }
 750
 751 void bn_sqr_comba4(r,a)
 752 BN_ULONG *r,*a;
 753         {
 754 #ifdef BN_LLONG
 755         BN_ULLONG t,tt;
 756 #else
 757         BN_ULONG bl,bh;
 758 #endif
 759         BN_ULONG t1,t2;
 760         BN_ULONG c1,c2,c3;
 761
 762         c1=0;
 763         c2=0;
 764         c3=0;
 765         sqr_add_c(a,0,c1,c2,c3);
 766         r[0]=c1;
 767         c1=0;
 768         sqr_add_c2(a,1,0,c2,c3,c1);
 769         r[1]=c2;
 770         c2=0;
 771         sqr_add_c(a,1,c3,c1,c2);
 772         sqr_add_c2(a,2,0,c3,c1,c2);
 773         r[2]=c3;
 774         c3=0;
 775         sqr_add_c2(a,3,0,c1,c2,c3);
 776         sqr_add_c2(a,2,1,c1,c2,c3);
 777         r[3]=c1;
 778         c1=0;
 779         sqr_add_c(a,2,c2,c3,c1);
 780         sqr_add_c2(a,3,1,c2,c3,c1);
 781         r[4]=c2;
 782         c2=0;
 783         sqr_add_c2(a,3,2,c3,c1,c2);
 784         r[5]=c3;
 785         c3=0;
 786         sqr_add_c(a,3,c1,c2,c3);
 787         r[6]=c1;
 788         r[7]=c2;
 789         }
 790 #else
 791
 792 /* hmm... is it faster just to do a multiply? */
 793 void bn_sqr_comba4(r,a)
 794 BN_ULONG *r,*a;
 795         {
 796         BN_ULONG t[8];
 797         bn_sqr_normal(r,a,4,t);
 798         }
 799
 800 void bn_sqr_comba8(r,a)
 801 BN_ULONG *r,*a;
 802         {
 803         BN_ULONG t[16];
 804         bn_sqr_normal(r,a,8,t);
 805         }
 806
 807 void bn_mul_comba4(r,a,b)
 808 BN_ULONG *r,*a,*b;
 809         {
 810         r[4]=bn_mul_words(    &(r[0]),a,4,b[0]);
 811         r[5]=bn_mul_add_words(&(r[1]),a,4,b[1]);
 812         r[6]=bn_mul_add_words(&(r[2]),a,4,b[2]);
 813         r[7]=bn_mul_add_words(&(r[3]),a,4,b[3]);
 814         }
 815
 816 void bn_mul_comba8(r,a,b)
 817 BN_ULONG *r,*a,*b;
 818         {
 819         r[ 8]=bn_mul_words(    &(r[0]),a,8,b[0]);
 820         r[ 9]=bn_mul_add_words(&(r[1]),a,8,b[1]);
 821         r[10]=bn_mul_add_words(&(r[2]),a,8,b[2]);
 822         r[11]=bn_mul_add_words(&(r[3]),a,8,b[3]);
 823         r[12]=bn_mul_add_words(&(r[4]),a,8,b[4]);
 824         r[13]=bn_mul_add_words(&(r[5]),a,8,b[5]);
 825         r[14]=bn_mul_add_words(&(r[6]),a,8,b[6]);
 826         r[15]=bn_mul_add_words(&(r[7]),a,8,b[7]);
 827         }
 828
 829 #endif /* BN_COMBA */