begriffs open source - freertos/blob - FreeRTOS-Plus/CyaSSL/ctaocrypt/src/asm.c

   1 /* asm.c
   2  *
   3  * Copyright (C) 2006-2012 Sawtooth Consulting Ltd.
   4  *
   5  * This file is part of CyaSSL.
   6  *
   7  * CyaSSL is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * CyaSSL is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23     #include <config.h>
  24 #endif
  25
  26 /*
  27  * Based on public domain TomsFastMath 0.10 by Tom St Denis, tomstdenis@iahu.ca,
  28  * http://math.libtomcrypt.com
  29  */
  30
  31
  32 /******************************************************************/
  33 /* fp_montgomery_reduce.c asm or generic */
  34 #if defined(TFM_X86) && !defined(TFM_SSE2)
  35 /* x86-32 code */
  36
  37 #define MONT_START
  38 #define MONT_FINI
  39 #define LOOP_END
  40 #define LOOP_START \
  41    mu = c[x] * mp
  42
  43 #define INNERMUL                                          \
  44 asm(                                                      \
  45    "movl %5,%%eax \n\t"                                   \
  46    "mull %4       \n\t"                                   \
  47    "addl %1,%%eax \n\t"                                   \
  48    "adcl $0,%%edx \n\t"                                   \
  49    "addl %%eax,%0 \n\t"                                   \
  50    "adcl $0,%%edx \n\t"                                   \
  51    "movl %%edx,%1 \n\t"                                   \
  52 :"=g"(_c[LO]), "=r"(cy)                                   \
  53 :"0"(_c[LO]), "1"(cy), "g"(mu), "g"(*tmpm++)              \
  54 : "%eax", "%edx", "%cc")
  55
  56 #define PROPCARRY                           \
  57 asm(                                        \
  58    "addl   %1,%0    \n\t"                   \
  59    "setb   %%al     \n\t"                   \
  60    "movzbl %%al,%1 \n\t"                    \
  61 :"=g"(_c[LO]), "=r"(cy)                     \
  62 :"0"(_c[LO]), "1"(cy)                       \
  63 : "%eax", "%cc")
  64
  65 /******************************************************************/
  66 #elif defined(TFM_X86_64)
  67 /* x86-64 code */
  68
  69 #define MONT_START
  70 #define MONT_FINI
  71 #define LOOP_END
  72 #define LOOP_START \
  73    mu = c[x] * mp
  74
  75 #define INNERMUL                                          \
  76 asm(                                                      \
  77    "movq %5,%%rax \n\t"                                   \
  78    "mulq %4       \n\t"                                   \
  79    "addq %1,%%rax \n\t"                                   \
  80    "adcq $0,%%rdx \n\t"                                   \
  81    "addq %%rax,%0 \n\t"                                   \
  82    "adcq $0,%%rdx \n\t"                                   \
  83    "movq %%rdx,%1 \n\t"                                   \
  84 :"=g"(_c[LO]), "=r"(cy)                                   \
  85 :"0"(_c[LO]), "1"(cy), "r"(mu), "r"(*tmpm++)              \
  86 : "%rax", "%rdx", "%cc")
  87
  88 #define INNERMUL8 \
  89  asm(                  \
  90  "movq 0(%5),%%rax    \n\t"  \
  91  "movq 0(%2),%%r10    \n\t"  \
  92  "movq 0x8(%5),%%r11  \n\t"  \
  93  "mulq %4             \n\t"  \
  94  "addq %%r10,%%rax    \n\t"  \
  95  "adcq $0,%%rdx       \n\t"  \
  96  "movq 0x8(%2),%%r10  \n\t"  \
  97  "addq %3,%%rax       \n\t"  \
  98  "adcq $0,%%rdx       \n\t"  \
  99  "movq %%rax,0(%0)    \n\t"  \
 100  "movq %%rdx,%1       \n\t"  \
 101  \
 102  "movq %%r11,%%rax    \n\t"  \
 103  "movq 0x10(%5),%%r11 \n\t"  \
 104  "mulq %4             \n\t"  \
 105  "addq %%r10,%%rax    \n\t"  \
 106  "adcq $0,%%rdx       \n\t"  \
 107  "movq 0x10(%2),%%r10 \n\t"  \
 108  "addq %3,%%rax       \n\t"  \
 109  "adcq $0,%%rdx       \n\t"  \
 110  "movq %%rax,0x8(%0)  \n\t"  \
 111  "movq %%rdx,%1       \n\t"  \
 112  \
 113  "movq %%r11,%%rax    \n\t"  \
 114  "movq 0x18(%5),%%r11 \n\t"  \
 115  "mulq %4             \n\t"  \
 116  "addq %%r10,%%rax    \n\t"  \
 117  "adcq $0,%%rdx       \n\t"  \
 118  "movq 0x18(%2),%%r10 \n\t"  \
 119  "addq %3,%%rax       \n\t"  \
 120  "adcq $0,%%rdx       \n\t"  \
 121  "movq %%rax,0x10(%0) \n\t"  \
 122  "movq %%rdx,%1       \n\t"  \
 123  \
 124  "movq %%r11,%%rax    \n\t"  \
 125  "movq 0x20(%5),%%r11 \n\t"  \
 126  "mulq %4             \n\t"  \
 127  "addq %%r10,%%rax    \n\t"  \
 128  "adcq $0,%%rdx       \n\t"  \
 129  "movq 0x20(%2),%%r10 \n\t"  \
 130  "addq %3,%%rax       \n\t"  \
 131  "adcq $0,%%rdx       \n\t"  \
 132  "movq %%rax,0x18(%0) \n\t"  \
 133  "movq %%rdx,%1       \n\t"  \
 134  \
 135  "movq %%r11,%%rax    \n\t"  \
 136  "movq 0x28(%5),%%r11 \n\t"  \
 137  "mulq %4             \n\t"  \
 138  "addq %%r10,%%rax    \n\t"  \
 139  "adcq $0,%%rdx       \n\t"  \
 140  "movq 0x28(%2),%%r10 \n\t"  \
 141  "addq %3,%%rax       \n\t"  \
 142  "adcq $0,%%rdx       \n\t"  \
 143  "movq %%rax,0x20(%0) \n\t"  \
 144  "movq %%rdx,%1       \n\t"  \
 145  \
 146  "movq %%r11,%%rax    \n\t"  \
 147  "movq 0x30(%5),%%r11 \n\t"  \
 148  "mulq %4             \n\t"  \
 149  "addq %%r10,%%rax    \n\t"  \
 150  "adcq $0,%%rdx       \n\t"  \
 151  "movq 0x30(%2),%%r10 \n\t"  \
 152  "addq %3,%%rax       \n\t"  \
 153  "adcq $0,%%rdx       \n\t"  \
 154  "movq %%rax,0x28(%0) \n\t"  \
 155  "movq %%rdx,%1       \n\t"  \
 156  \
 157  "movq %%r11,%%rax    \n\t"  \
 158  "movq 0x38(%5),%%r11 \n\t"  \
 159  "mulq %4             \n\t"  \
 160  "addq %%r10,%%rax    \n\t"  \
 161  "adcq $0,%%rdx       \n\t"  \
 162  "movq 0x38(%2),%%r10 \n\t"  \
 163  "addq %3,%%rax       \n\t"  \
 164  "adcq $0,%%rdx       \n\t"  \
 165  "movq %%rax,0x30(%0) \n\t"  \
 166  "movq %%rdx,%1       \n\t"  \
 167  \
 168  "movq %%r11,%%rax    \n\t"  \
 169  "mulq %4             \n\t"  \
 170  "addq %%r10,%%rax    \n\t"  \
 171  "adcq $0,%%rdx       \n\t"  \
 172  "addq %3,%%rax       \n\t"  \
 173  "adcq $0,%%rdx       \n\t"  \
 174  "movq %%rax,0x38(%0) \n\t"  \
 175  "movq %%rdx,%1       \n\t"  \
 176  \
 177 :"=r"(_c), "=r"(cy)                    \
 178 : "0"(_c),  "1"(cy), "g"(mu), "r"(tmpm)\
 179 : "%rax", "%rdx", "%r10", "%r11", "%cc")
 180
 181
 182 #define PROPCARRY                           \
 183 asm(                                        \
 184    "addq   %1,%0    \n\t"                   \
 185    "setb   %%al     \n\t"                   \
 186    "movzbq %%al,%1 \n\t"                    \
 187 :"=g"(_c[LO]), "=r"(cy)                     \
 188 :"0"(_c[LO]), "1"(cy)                       \
 189 : "%rax", "%cc")
 190
 191 /******************************************************************/
 192 #elif defined(TFM_SSE2)
 193 /* SSE2 code (assumes 32-bit fp_digits) */
 194 /* XMM register assignments:
 195  * xmm0  *tmpm++, then Mu * (*tmpm++)
 196  * xmm1  c[x], then Mu
 197  * xmm2  mp
 198  * xmm3  cy
 199  * xmm4  _c[LO]
 200  */
 201
 202 #define MONT_START \
 203    asm("movd %0,%%mm2"::"g"(mp))
 204
 205 #define MONT_FINI \
 206    asm("emms")
 207
 208 #define LOOP_START          \
 209 asm(                        \
 210 "movd %0,%%mm1        \n\t" \
 211 "pxor %%mm3,%%mm3     \n\t" \
 212 "pmuludq %%mm2,%%mm1  \n\t" \
 213 :: "g"(c[x]))
 214
 215 /* pmuludq on mmx registers does a 32x32->64 multiply. */
 216 #define INNERMUL               \
 217 asm(                           \
 218    "movd %1,%%mm4        \n\t" \
 219    "movd %2,%%mm0        \n\t" \
 220    "paddq %%mm4,%%mm3    \n\t" \
 221    "pmuludq %%mm1,%%mm0  \n\t" \
 222    "paddq %%mm0,%%mm3    \n\t" \
 223    "movd %%mm3,%0        \n\t" \
 224    "psrlq $32, %%mm3     \n\t" \
 225 :"=g"(_c[LO]) : "0"(_c[LO]), "g"(*tmpm++) );
 226
 227 #define INNERMUL8 \
 228 asm(                           \
 229    "movd 0(%1),%%mm4     \n\t" \
 230    "movd 0(%2),%%mm0     \n\t" \
 231    "paddq %%mm4,%%mm3    \n\t" \
 232    "pmuludq %%mm1,%%mm0  \n\t" \
 233    "movd 4(%2),%%mm5     \n\t" \
 234    "paddq %%mm0,%%mm3    \n\t" \
 235    "movd 4(%1),%%mm6     \n\t" \
 236    "movd %%mm3,0(%0)     \n\t" \
 237    "psrlq $32, %%mm3     \n\t" \
 238 \
 239    "paddq %%mm6,%%mm3    \n\t" \
 240    "pmuludq %%mm1,%%mm5  \n\t" \
 241    "movd 8(%2),%%mm6     \n\t" \
 242    "paddq %%mm5,%%mm3    \n\t" \
 243    "movd 8(%1),%%mm7     \n\t" \
 244    "movd %%mm3,4(%0)     \n\t" \
 245    "psrlq $32, %%mm3     \n\t" \
 246 \
 247    "paddq %%mm7,%%mm3    \n\t" \
 248    "pmuludq %%mm1,%%mm6  \n\t" \
 249    "movd 12(%2),%%mm7    \n\t" \
 250    "paddq %%mm6,%%mm3    \n\t" \
 251    "movd 12(%1),%%mm5     \n\t" \
 252    "movd %%mm3,8(%0)     \n\t" \
 253    "psrlq $32, %%mm3     \n\t" \
 254 \
 255    "paddq %%mm5,%%mm3    \n\t" \
 256    "pmuludq %%mm1,%%mm7  \n\t" \
 257    "movd 16(%2),%%mm5    \n\t" \
 258    "paddq %%mm7,%%mm3    \n\t" \
 259    "movd 16(%1),%%mm6    \n\t" \
 260    "movd %%mm3,12(%0)    \n\t" \
 261    "psrlq $32, %%mm3     \n\t" \
 262 \
 263    "paddq %%mm6,%%mm3    \n\t" \
 264    "pmuludq %%mm1,%%mm5  \n\t" \
 265    "movd 20(%2),%%mm6    \n\t" \
 266    "paddq %%mm5,%%mm3    \n\t" \
 267    "movd 20(%1),%%mm7    \n\t" \
 268    "movd %%mm3,16(%0)    \n\t" \
 269    "psrlq $32, %%mm3     \n\t" \
 270 \
 271    "paddq %%mm7,%%mm3    \n\t" \
 272    "pmuludq %%mm1,%%mm6  \n\t" \
 273    "movd 24(%2),%%mm7    \n\t" \
 274    "paddq %%mm6,%%mm3    \n\t" \
 275    "movd 24(%1),%%mm5     \n\t" \
 276    "movd %%mm3,20(%0)    \n\t" \
 277    "psrlq $32, %%mm3     \n\t" \
 278 \
 279    "paddq %%mm5,%%mm3    \n\t" \
 280    "pmuludq %%mm1,%%mm7  \n\t" \
 281    "movd 28(%2),%%mm5    \n\t" \
 282    "paddq %%mm7,%%mm3    \n\t" \
 283    "movd 28(%1),%%mm6    \n\t" \
 284    "movd %%mm3,24(%0)    \n\t" \
 285    "psrlq $32, %%mm3     \n\t" \
 286 \
 287    "paddq %%mm6,%%mm3    \n\t" \
 288    "pmuludq %%mm1,%%mm5  \n\t" \
 289    "paddq %%mm5,%%mm3    \n\t" \
 290    "movd %%mm3,28(%0)    \n\t" \
 291    "psrlq $32, %%mm3     \n\t" \
 292 :"=r"(_c) : "0"(_c), "r"(tmpm) );
 293
 294 /* TAO switched tmpm from "g" to "r" after gcc tried to index the indexed stack
 295    pointer */
 296
 297 #define LOOP_END \
 298 asm( "movd %%mm3,%0  \n" :"=r"(cy))
 299
 300 #define PROPCARRY                           \
 301 asm(                                        \
 302    "addl   %1,%0    \n\t"                   \
 303    "setb   %%al     \n\t"                   \
 304    "movzbl %%al,%1 \n\t"                    \
 305 :"=g"(_c[LO]), "=r"(cy)                     \
 306 :"0"(_c[LO]), "1"(cy)                       \
 307 : "%eax", "%cc")
 308
 309 /******************************************************************/
 310 #elif defined(TFM_ARM)
 311    /* ARMv4 code */
 312
 313 #define MONT_START
 314 #define MONT_FINI
 315 #define LOOP_END
 316 #define LOOP_START \
 317    mu = c[x] * mp
 318
 319 #define INNERMUL                    \
 320 asm(                                \
 321     " LDR    r0,%1            \n\t" \
 322     " ADDS   r0,r0,%0         \n\t" \
 323     " MOVCS  %0,#1            \n\t" \
 324     " MOVCC  %0,#0            \n\t" \
 325     " UMLAL  r0,%0,%3,%4      \n\t" \
 326     " STR    r0,%1            \n\t" \
 327 :"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c[0]):"r0","%cc");
 328
 329 #define PROPCARRY                  \
 330 asm(                               \
 331     " LDR   r0,%1            \n\t" \
 332     " ADDS  r0,r0,%0         \n\t" \
 333     " STR   r0,%1            \n\t" \
 334     " MOVCS %0,#1            \n\t" \
 335     " MOVCC %0,#0            \n\t" \
 336 :"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"r0","%cc");
 337
 338 #elif defined(TFM_PPC32)
 339
 340 /* PPC32 */
 341 #define MONT_START
 342 #define MONT_FINI
 343 #define LOOP_END
 344 #define LOOP_START \
 345    mu = c[x] * mp
 346
 347 #define INNERMUL                     \
 348 asm(                                 \
 349    " mullw    16,%3,%4       \n\t"   \
 350    " mulhwu   17,%3,%4       \n\t"   \
 351    " addc     16,16,%0       \n\t"   \
 352    " addze    17,17          \n\t"   \
 353    " lwz      18,%1          \n\t"   \
 354    " addc     16,16,18       \n\t"   \
 355    " addze    %0,17          \n\t"   \
 356    " stw      16,%1          \n\t"   \
 357 :"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(tmpm[0]),"1"(_c[0]):"16", "17", "18","%cc"); ++tmpm;
 358
 359 #define PROPCARRY                    \
 360 asm(                                 \
 361    " lwz      16,%1         \n\t"    \
 362    " addc     16,16,%0      \n\t"    \
 363    " stw      16,%1         \n\t"    \
 364    " xor      %0,%0,%0      \n\t"    \
 365    " addze    %0,%0         \n\t"    \
 366 :"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"16","%cc");
 367
 368 #elif defined(TFM_PPC64)
 369
 370 /* PPC64 */
 371 #define MONT_START
 372 #define MONT_FINI
 373 #define LOOP_END
 374 #define LOOP_START \
 375    mu = c[x] * mp
 376
 377 #define INNERMUL                     \
 378 asm(                                 \
 379    " mulld    16,%3,%4       \n\t"   \
 380    " mulhdu   17,%3,%4       \n\t"   \
 381    " addc     16,16,%0       \n\t"   \
 382    " addze    17,17          \n\t"   \
 383    " ldx      18,0,%1        \n\t"   \
 384    " addc     16,16,18       \n\t"   \
 385    " addze    %0,17          \n\t"   \
 386    " sdx      16,0,%1        \n\t"   \
 387 :"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(tmpm[0]),"1"(_c[0]):"16", "17", "18","%cc"); ++tmpm;
 388
 389 #define PROPCARRY                    \
 390 asm(                                 \
 391    " ldx      16,0,%1       \n\t"    \
 392    " addc     16,16,%0      \n\t"    \
 393    " sdx      16,0,%1       \n\t"    \
 394    " xor      %0,%0,%0      \n\t"    \
 395    " addze    %0,%0         \n\t"    \
 396 :"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"16","%cc");
 397
 398 /******************************************************************/
 399
 400 #elif defined(TFM_AVR32)
 401
 402 /* AVR32 */
 403 #define MONT_START
 404 #define MONT_FINI
 405 #define LOOP_END
 406 #define LOOP_START \
 407    mu = c[x] * mp
 408
 409 #define INNERMUL                    \
 410 asm(                                \
 411     " ld.w   r2,%1            \n\t" \
 412     " add    r2,%0            \n\t" \
 413     " eor    r3,r3            \n\t" \
 414     " acr    r3               \n\t" \
 415     " macu.d r2,%3,%4         \n\t" \
 416     " st.w   %1,r2            \n\t" \
 417     " mov    %0,r3            \n\t" \
 418 :"=r"(cy),"=r"(_c):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c):"r2","r3");
 419
 420 #define PROPCARRY                    \
 421 asm(                                 \
 422    " ld.w     r2,%1         \n\t"    \
 423    " add      r2,%0         \n\t"    \
 424    " st.w     %1,r2         \n\t"    \
 425    " eor      %0,%0         \n\t"    \
 426    " acr      %0            \n\t"    \
 427 :"=r"(cy),"=r"(&_c[0]):"0"(cy),"1"(&_c[0]):"r2","%cc");
 428
 429 #else
 430
 431 /* ISO C code */
 432 #define MONT_START
 433 #define MONT_FINI
 434 #define LOOP_END
 435 #define LOOP_START \
 436    mu = c[x] * mp
 437
 438 #define INNERMUL                                      \
 439    do { fp_word t;                                    \
 440    _c[0] = t  = ((fp_word)_c[0] + (fp_word)cy) +      \
 441                 (((fp_word)mu) * ((fp_word)*tmpm++)); \
 442    cy = (t >> DIGIT_BIT);                             \
 443    } while (0)
 444
 445 #define PROPCARRY \
 446    do { fp_digit t = _c[0] += cy; cy = (t < cy); } while (0)
 447
 448 #endif
 449 /******************************************************************/
 450
 451
 452 #define LO  0
 453 /* end fp_montogomery_reduce.c asm */
 454
 455
 456 /* start fp_sqr_comba.c asm */
 457 #if defined(TFM_X86)
 458
 459 /* x86-32 optimized */
 460
 461 #define COMBA_START
 462
 463 #define CLEAR_CARRY \
 464    c0 = c1 = c2 = 0;
 465
 466 #define COMBA_STORE(x) \
 467    x = c0;
 468
 469 #define COMBA_STORE2(x) \
 470    x = c1;
 471
 472 #define CARRY_FORWARD \
 473    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 474
 475 #define COMBA_FINI
 476
 477 #define SQRADD(i, j)                                      \
 478 asm(                                            \
 479      "movl  %6,%%eax     \n\t"                            \
 480      "mull  %%eax        \n\t"                            \
 481      "addl  %%eax,%0     \n\t"                            \
 482      "adcl  %%edx,%1     \n\t"                            \
 483      "adcl  $0,%2        \n\t"                            \
 484      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i) :"%eax","%edx","%cc");
 485
 486 #define SQRADD2(i, j)                                     \
 487 asm(                                            \
 488      "movl  %6,%%eax     \n\t"                            \
 489      "mull  %7           \n\t"                            \
 490      "addl  %%eax,%0     \n\t"                            \
 491      "adcl  %%edx,%1     \n\t"                            \
 492      "adcl  $0,%2        \n\t"                            \
 493      "addl  %%eax,%0     \n\t"                            \
 494      "adcl  %%edx,%1     \n\t"                            \
 495      "adcl  $0,%2        \n\t"                            \
 496      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%edx", "%cc");
 497
 498 #define SQRADDSC(i, j)                                    \
 499 asm(                                                     \
 500      "movl  %3,%%eax     \n\t"                            \
 501      "mull  %4           \n\t"                            \
 502      "movl  %%eax,%0     \n\t"                            \
 503      "movl  %%edx,%1     \n\t"                            \
 504      "xorl  %2,%2        \n\t"                            \
 505      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%eax","%edx","%cc");
 506
 507 /* TAO removed sc0,1,2 as input to remove warning so %6,%7 become %3,%4 */
 508
 509 #define SQRADDAC(i, j)                                    \
 510 asm(                                                     \
 511      "movl  %6,%%eax     \n\t"                            \
 512      "mull  %7           \n\t"                            \
 513      "addl  %%eax,%0     \n\t"                            \
 514      "adcl  %%edx,%1     \n\t"                            \
 515      "adcl  $0,%2        \n\t"                            \
 516      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%eax","%edx","%cc");
 517
 518 #define SQRADDDB                                          \
 519 asm(                                                     \
 520      "addl %6,%0         \n\t"                            \
 521      "adcl %7,%1         \n\t"                            \
 522      "adcl %8,%2         \n\t"                            \
 523      "addl %6,%0         \n\t"                            \
 524      "adcl %7,%1         \n\t"                            \
 525      "adcl %8,%2         \n\t"                            \
 526      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc");
 527
 528 #elif defined(TFM_X86_64)
 529 /* x86-64 optimized */
 530
 531 #define COMBA_START
 532
 533 #define CLEAR_CARRY \
 534    c0 = c1 = c2 = 0;
 535
 536 #define COMBA_STORE(x) \
 537    x = c0;
 538
 539 #define COMBA_STORE2(x) \
 540    x = c1;
 541
 542 #define CARRY_FORWARD \
 543    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 544
 545 #define COMBA_FINI
 546
 547 #define SQRADD(i, j)                                      \
 548 asm(                                                     \
 549      "movq  %6,%%rax     \n\t"                            \
 550      "mulq  %%rax        \n\t"                            \
 551      "addq  %%rax,%0     \n\t"                            \
 552      "adcq  %%rdx,%1     \n\t"                            \
 553      "adcq  $0,%2        \n\t"                            \
 554      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i) :"%rax","%rdx","%cc");
 555
 556 #define SQRADD2(i, j)                                     \
 557 asm(                                                     \
 558      "movq  %6,%%rax     \n\t"                            \
 559      "mulq  %7           \n\t"                            \
 560      "addq  %%rax,%0     \n\t"                            \
 561      "adcq  %%rdx,%1     \n\t"                            \
 562      "adcq  $0,%2        \n\t"                            \
 563      "addq  %%rax,%0     \n\t"                            \
 564      "adcq  %%rdx,%1     \n\t"                            \
 565      "adcq  $0,%2        \n\t"                            \
 566      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j)  :"%rax","%rdx","%cc");
 567
 568 #define SQRADDSC(i, j)                                    \
 569 asm(                                                     \
 570      "movq  %3,%%rax     \n\t"                            \
 571      "mulq  %4           \n\t"                            \
 572      "movq  %%rax,%0     \n\t"                            \
 573      "movq  %%rdx,%1     \n\t"                            \
 574      "xorq  %2,%2        \n\t"                            \
 575      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%rax","%rdx","%cc");
 576
 577 /* TAO removed sc0,1,2 as input to remove warning so %6,%7 become %3,%4 */
 578
 579 #define SQRADDAC(i, j)                                                         \
 580 asm(                                                     \
 581      "movq  %6,%%rax     \n\t"                            \
 582      "mulq  %7           \n\t"                            \
 583      "addq  %%rax,%0     \n\t"                            \
 584      "adcq  %%rdx,%1     \n\t"                            \
 585      "adcq  $0,%2        \n\t"                            \
 586      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","%cc");
 587
 588 #define SQRADDDB                                          \
 589 asm(                                                     \
 590      "addq %6,%0         \n\t"                            \
 591      "adcq %7,%1         \n\t"                            \
 592      "adcq %8,%2         \n\t"                            \
 593      "addq %6,%0         \n\t"                            \
 594      "adcq %7,%1         \n\t"                            \
 595      "adcq %8,%2         \n\t"                            \
 596      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc");
 597
 598 #elif defined(TFM_SSE2)
 599
 600 /* SSE2 Optimized */
 601 #define COMBA_START
 602
 603 #define CLEAR_CARRY \
 604    c0 = c1 = c2 = 0;
 605
 606 #define COMBA_STORE(x) \
 607    x = c0;
 608
 609 #define COMBA_STORE2(x) \
 610    x = c1;
 611
 612 #define CARRY_FORWARD \
 613    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 614
 615 #define COMBA_FINI \
 616    asm("emms");
 617
 618 #define SQRADD(i, j)                                      \
 619 asm(                                            \
 620      "movd  %6,%%mm0     \n\t"                            \
 621      "pmuludq %%mm0,%%mm0\n\t"                            \
 622      "movd  %%mm0,%%eax  \n\t"                            \
 623      "psrlq $32,%%mm0    \n\t"                            \
 624      "addl  %%eax,%0     \n\t"                            \
 625      "movd  %%mm0,%%eax  \n\t"                            \
 626      "adcl  %%eax,%1     \n\t"                            \
 627      "adcl  $0,%2        \n\t"                            \
 628      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i) :"%eax","%cc");
 629
 630 #define SQRADD2(i, j)                                     \
 631 asm(                                            \
 632      "movd  %6,%%mm0     \n\t"                            \
 633      "movd  %7,%%mm1     \n\t"                            \
 634      "pmuludq %%mm1,%%mm0\n\t"                            \
 635      "movd  %%mm0,%%eax  \n\t"                            \
 636      "psrlq $32,%%mm0    \n\t"                            \
 637      "movd  %%mm0,%%edx  \n\t"                            \
 638      "addl  %%eax,%0     \n\t"                            \
 639      "adcl  %%edx,%1     \n\t"                            \
 640      "adcl  $0,%2        \n\t"                            \
 641      "addl  %%eax,%0     \n\t"                            \
 642      "adcl  %%edx,%1     \n\t"                            \
 643      "adcl  $0,%2        \n\t"                            \
 644      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%edx","%cc");
 645
 646 #define SQRADDSC(i, j)                                                         \
 647 asm(                                            \
 648      "movd  %3,%%mm0     \n\t"                            \
 649      "movd  %4,%%mm1     \n\t"                            \
 650      "pmuludq %%mm1,%%mm0\n\t"                            \
 651      "movd  %%mm0,%0     \n\t"                            \
 652      "psrlq $32,%%mm0    \n\t"                            \
 653      "movd  %%mm0,%1     \n\t"                            \
 654      "xorl  %2,%2        \n\t"                            \
 655      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "m"(i), "m"(j));
 656
 657 /* TAO removed sc0,1,2 as input to remove warning so %6,%7 become %3,%4 */
 658
 659 #define SQRADDAC(i, j)                                                         \
 660 asm(                                            \
 661      "movd  %6,%%mm0     \n\t"                            \
 662      "movd  %7,%%mm1     \n\t"                            \
 663      "pmuludq %%mm1,%%mm0\n\t"                            \
 664      "movd  %%mm0,%%eax  \n\t"                            \
 665      "psrlq $32,%%mm0    \n\t"                            \
 666      "movd  %%mm0,%%edx  \n\t"                            \
 667      "addl  %%eax,%0     \n\t"                            \
 668      "adcl  %%edx,%1     \n\t"                            \
 669      "adcl  $0,%2        \n\t"                            \
 670      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j)  :"%eax","%edx","%cc");
 671
 672 #define SQRADDDB                                          \
 673 asm(                                                     \
 674      "addl %6,%0         \n\t"                            \
 675      "adcl %7,%1         \n\t"                            \
 676      "adcl %8,%2         \n\t"                            \
 677      "addl %6,%0         \n\t"                            \
 678      "adcl %7,%1         \n\t"                            \
 679      "adcl %8,%2         \n\t"                            \
 680      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc");
 681
 682 #elif defined(TFM_ARM)
 683
 684 /* ARM code */
 685
 686 #define COMBA_START
 687
 688 #define CLEAR_CARRY \
 689    c0 = c1 = c2 = 0;
 690
 691 #define COMBA_STORE(x) \
 692    x = c0;
 693
 694 #define COMBA_STORE2(x) \
 695    x = c1;
 696
 697 #define CARRY_FORWARD \
 698    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 699
 700 #define COMBA_FINI
 701
 702 /* multiplies point i and j, updates carry "c1" and digit c2 */
 703 #define SQRADD(i, j)                                             \
 704 asm(                                                             \
 705 "  UMULL  r0,r1,%6,%6              \n\t"                         \
 706 "  ADDS   %0,%0,r0                 \n\t"                         \
 707 "  ADCS   %1,%1,r1                 \n\t"                         \
 708 "  ADC    %2,%2,#0                 \n\t"                         \
 709 :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i) : "r0", "r1", "%cc");
 710
 711 /* for squaring some of the terms are doubled... */
 712 #define SQRADD2(i, j)                                            \
 713 asm(                                                             \
 714 "  UMULL  r0,r1,%6,%7              \n\t"                         \
 715 "  ADDS   %0,%0,r0                 \n\t"                         \
 716 "  ADCS   %1,%1,r1                 \n\t"                         \
 717 "  ADC    %2,%2,#0                 \n\t"                         \
 718 "  ADDS   %0,%0,r0                 \n\t"                         \
 719 "  ADCS   %1,%1,r1                 \n\t"                         \
 720 "  ADC    %2,%2,#0                 \n\t"                         \
 721 :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "%cc");
 722
 723 #define SQRADDSC(i, j)                                           \
 724 asm(                                                             \
 725 "  UMULL  %0,%1,%6,%7              \n\t"                         \
 726 "  SUB    %2,%2,%2                 \n\t"                         \
 727 :"=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j) : "%cc");
 728
 729 #define SQRADDAC(i, j)                                           \
 730 asm(                                                             \
 731 "  UMULL  r0,r1,%6,%7              \n\t"                         \
 732 "  ADDS   %0,%0,r0                 \n\t"                         \
 733 "  ADCS   %1,%1,r1                 \n\t"                         \
 734 "  ADC    %2,%2,#0                 \n\t"                         \
 735 :"=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j) : "r0", "r1", "%cc");
 736
 737 #define SQRADDDB                                                 \
 738 asm(                                                             \
 739 "  ADDS  %0,%0,%3                     \n\t"                      \
 740 "  ADCS  %1,%1,%4                     \n\t"                      \
 741 "  ADC   %2,%2,%5                     \n\t"                      \
 742 "  ADDS  %0,%0,%3                     \n\t"                      \
 743 "  ADCS  %1,%1,%4                     \n\t"                      \
 744 "  ADC   %2,%2,%5                     \n\t"                      \
 745 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc");
 746
 747 #elif defined(TFM_PPC32)
 748
 749 /* PPC32 */
 750
 751 #define COMBA_START
 752
 753 #define CLEAR_CARRY \
 754    c0 = c1 = c2 = 0;
 755
 756 #define COMBA_STORE(x) \
 757    x = c0;
 758
 759 #define COMBA_STORE2(x) \
 760    x = c1;
 761
 762 #define CARRY_FORWARD \
 763    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 764
 765 #define COMBA_FINI
 766
 767 /* multiplies point i and j, updates carry "c1" and digit c2 */
 768 #define SQRADD(i, j)             \
 769 asm(                             \
 770    " mullw  16,%6,%6       \n\t" \
 771    " addc   %0,%0,16       \n\t" \
 772    " mulhwu 16,%6,%6       \n\t" \
 773    " adde   %1,%1,16       \n\t" \
 774    " addze  %2,%2          \n\t" \
 775 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"16","%cc");
 776
 777 /* for squaring some of the terms are doubled... */
 778 #define SQRADD2(i, j)            \
 779 asm(                             \
 780    " mullw  16,%6,%7       \n\t" \
 781    " mulhwu 17,%6,%7       \n\t" \
 782    " addc   %0,%0,16       \n\t" \
 783    " adde   %1,%1,17       \n\t" \
 784    " addze  %2,%2          \n\t" \
 785    " addc   %0,%0,16       \n\t" \
 786    " adde   %1,%1,17       \n\t" \
 787    " addze  %2,%2          \n\t" \
 788 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"16", "17","%cc");
 789
 790 #define SQRADDSC(i, j)            \
 791 asm(                              \
 792    " mullw  %0,%6,%7        \n\t" \
 793    " mulhwu %1,%6,%7        \n\t" \
 794    " xor    %2,%2,%2        \n\t" \
 795 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "%cc");
 796
 797 #define SQRADDAC(i, j)           \
 798 asm(                             \
 799    " mullw  16,%6,%7       \n\t" \
 800    " addc   %0,%0,16       \n\t" \
 801    " mulhwu 16,%6,%7       \n\t" \
 802    " adde   %1,%1,16       \n\t" \
 803    " addze  %2,%2          \n\t" \
 804 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"16", "%cc");
 805
 806 #define SQRADDDB                  \
 807 asm(                              \
 808    " addc   %0,%0,%3        \n\t" \
 809    " adde   %1,%1,%4        \n\t" \
 810    " adde   %2,%2,%5        \n\t" \
 811    " addc   %0,%0,%3        \n\t" \
 812    " adde   %1,%1,%4        \n\t" \
 813    " adde   %2,%2,%5        \n\t" \
 814 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc");
 815
 816 #elif defined(TFM_PPC64)
 817 /* PPC64 */
 818
 819 #define COMBA_START
 820
 821 #define CLEAR_CARRY \
 822    c0 = c1 = c2 = 0;
 823
 824 #define COMBA_STORE(x) \
 825    x = c0;
 826
 827 #define COMBA_STORE2(x) \
 828    x = c1;
 829
 830 #define CARRY_FORWARD \
 831    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 832
 833 #define COMBA_FINI
 834
 835 /* multiplies point i and j, updates carry "c1" and digit c2 */
 836 #define SQRADD(i, j)             \
 837 asm(                             \
 838    " mulld  16,%6,%6       \n\t" \
 839    " addc   %0,%0,16       \n\t" \
 840    " mulhdu 16,%6,%6       \n\t" \
 841    " adde   %1,%1,16       \n\t" \
 842    " addze  %2,%2          \n\t" \
 843 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"16","%cc");
 844
 845 /* for squaring some of the terms are doubled... */
 846 #define SQRADD2(i, j)            \
 847 asm(                             \
 848    " mulld  16,%6,%7       \n\t" \
 849    " mulhdu 17,%6,%7       \n\t" \
 850    " addc   %0,%0,16       \n\t" \
 851    " adde   %1,%1,17       \n\t" \
 852    " addze  %2,%2          \n\t" \
 853    " addc   %0,%0,16       \n\t" \
 854    " adde   %1,%1,17       \n\t" \
 855    " addze  %2,%2          \n\t" \
 856 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"16", "17","%cc");
 857
 858 #define SQRADDSC(i, j)            \
 859 asm(                              \
 860    " mulld  %0,%6,%7        \n\t" \
 861    " mulhdu %1,%6,%7        \n\t" \
 862    " xor    %2,%2,%2        \n\t" \
 863 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "%cc");
 864
 865 #define SQRADDAC(i, j)           \
 866 asm(                             \
 867    " mulld  16,%6,%7       \n\t" \
 868    " addc   %0,%0,16       \n\t" \
 869    " mulhdu 16,%6,%7       \n\t" \
 870    " adde   %1,%1,16       \n\t" \
 871    " addze  %2,%2          \n\t" \
 872 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"16", "%cc");
 873
 874 #define SQRADDDB                  \
 875 asm(                              \
 876    " addc   %0,%0,%3        \n\t" \
 877    " adde   %1,%1,%4        \n\t" \
 878    " adde   %2,%2,%5        \n\t" \
 879    " addc   %0,%0,%3        \n\t" \
 880    " adde   %1,%1,%4        \n\t" \
 881    " adde   %2,%2,%5        \n\t" \
 882 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc");
 883
 884
 885 #elif defined(TFM_AVR32)
 886
 887 /* AVR32 */
 888
 889 #define COMBA_START
 890
 891 #define CLEAR_CARRY \
 892    c0 = c1 = c2 = 0;
 893
 894 #define COMBA_STORE(x) \
 895    x = c0;
 896
 897 #define COMBA_STORE2(x) \
 898    x = c1;
 899
 900 #define CARRY_FORWARD \
 901    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 902
 903 #define COMBA_FINI
 904
 905 /* multiplies point i and j, updates carry "c1" and digit c2 */
 906 #define SQRADD(i, j)             \
 907 asm(                             \
 908    " mulu.d r2,%6,%6       \n\t" \
 909    " add    %0,%0,r2       \n\t" \
 910    " adc    %1,%1,r3       \n\t" \
 911    " acr    %2             \n\t" \
 912 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"r2","r3");
 913
 914 /* for squaring some of the terms are doubled... */
 915 #define SQRADD2(i, j)            \
 916 asm(                             \
 917    " mulu.d r2,%6,%7       \n\t" \
 918    " add    %0,%0,r2       \n\t" \
 919    " adc    %1,%1,r3       \n\t" \
 920    " acr    %2,            \n\t" \
 921    " add    %0,%0,r2       \n\t" \
 922    " adc    %1,%1,r3       \n\t" \
 923    " acr    %2,            \n\t" \
 924 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r2", "r3");
 925
 926 #define SQRADDSC(i, j)            \
 927 asm(                              \
 928    " mulu.d r2,%6,%7        \n\t" \
 929    " mov    %0,r2           \n\t" \
 930    " mov    %1,r3           \n\t" \
 931    " eor    %2,%2           \n\t" \
 932 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "r2", "r3");
 933
 934 #define SQRADDAC(i, j)           \
 935 asm(                             \
 936    " mulu.d r2,%6,%7       \n\t" \
 937    " add    %0,%0,r2       \n\t" \
 938    " adc    %1,%1,r3       \n\t" \
 939    " acr    %2             \n\t" \
 940 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"r2", "r3");
 941
 942 #define SQRADDDB                  \
 943 asm(                              \
 944    " add    %0,%0,%3        \n\t" \
 945    " adc    %1,%1,%4        \n\t" \
 946    " adc    %2,%2,%5        \n\t" \
 947    " add    %0,%0,%3        \n\t" \
 948    " adc    %1,%1,%4        \n\t" \
 949    " adc    %2,%2,%5        \n\t" \
 950 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc");
 951
 952
 953 #else
 954
 955 #define TFM_ISO
 956
 957 /* ISO C portable code */
 958
 959 #define COMBA_START
 960
 961 #define CLEAR_CARRY \
 962    c0 = c1 = c2 = 0;
 963
 964 #define COMBA_STORE(x) \
 965    x = c0;
 966
 967 #define COMBA_STORE2(x) \
 968    x = c1;
 969
 970 #define CARRY_FORWARD \
 971    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 972
 973 #define COMBA_FINI
 974
 975 /* multiplies point i and j, updates carry "c1" and digit c2 */
 976 #define SQRADD(i, j)                                 \
 977    do { fp_word t;                                   \
 978    t = c0 + ((fp_word)i) * ((fp_word)j);  c0 = t;    \
 979    t = c1 + (t >> DIGIT_BIT);             c1 = t; c2 += t >> DIGIT_BIT; \
 980    } while (0);
 981
 982
 983 /* for squaring some of the terms are doubled... */
 984 #define SQRADD2(i, j)                                                 \
 985    do { fp_word t;                                                    \
 986    t  = ((fp_word)i) * ((fp_word)j);                                  \
 987    tt = (fp_word)c0 + t;                 c0 = tt;                              \
 988    tt = (fp_word)c1 + (tt >> DIGIT_BIT); c1 = tt; c2 += tt >> DIGIT_BIT;       \
 989    tt = (fp_word)c0 + t;                 c0 = tt;                              \
 990    tt = (fp_word)c1 + (tt >> DIGIT_BIT); c1 = tt; c2 += tt >> DIGIT_BIT;       \
 991    } while (0);
 992
 993 #define SQRADDSC(i, j)                                                         \
 994    do { fp_word t;                                                             \
 995       t =  ((fp_word)i) * ((fp_word)j);                                        \
 996       sc0 = (fp_digit)t; sc1 = (t >> DIGIT_BIT); sc2 = 0;                      \
 997    } while (0);
 998
 999 #define SQRADDAC(i, j)                                                         \
1000    do { fp_word t;                                                             \
1001    t = sc0 + ((fp_word)i) * ((fp_word)j);  sc0 = t;                            \
1002    t = sc1 + (t >> DIGIT_BIT);             sc1 = t; sc2 += t >> DIGIT_BIT;     \
1003    } while (0);
1004
1005 #define SQRADDDB                                                               \
1006    do { fp_word t;                                                             \
1007    t = ((fp_word)sc0) + ((fp_word)sc0) + c0; c0 = t;                                                 \
1008    t = ((fp_word)sc1) + ((fp_word)sc1) + c1 + (t >> DIGIT_BIT); c1 = t;                              \
1009    c2 = c2 + ((fp_word)sc2) + ((fp_word)sc2) + (t >> DIGIT_BIT);                                     \
1010    } while (0);
1011
1012 #endif
1013
1014 #ifdef TFM_SMALL_SET
1015 #include "fp_sqr_comba_small_set.i"
1016 #include "fp_sqr_comba_3.i"
1017 #include "fp_sqr_comba_4.i"
1018 #include "fp_sqr_comba_6.i"
1019 #include "fp_sqr_comba_7.i"
1020 #include "fp_sqr_comba_8.i"
1021 #include "fp_sqr_comba_9.i"
1022 #include "fp_sqr_comba_12.i"
1023 #include "fp_sqr_comba_17.i"
1024 #include "fp_sqr_comba_20.i"
1025 #include "fp_sqr_comba_24.i"
1026 #include "fp_sqr_comba_28.i"
1027 #include "fp_sqr_comba_32.i"
1028 #include "fp_sqr_comba_48.i"
1029 #include "fp_sqr_comba_64.i"
1030 #endif
1031 /* end fp_sqr_comba.c asm */
1032
1033 /* start fp_mul_comba.c asm */
1034 /* these are the combas.  Worship them. */
1035 #if defined(TFM_X86)
1036 /* Generic x86 optimized code */
1037
1038 /* anything you need at the start */
1039 #define COMBA_START
1040
1041 /* clear the chaining variables */
1042 #define COMBA_CLEAR \
1043    c0 = c1 = c2 = 0;
1044
1045 /* forward the carry to the next digit */
1046 #define COMBA_FORWARD \
1047    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1048
1049 /* store the first sum */
1050 #define COMBA_STORE(x) \
1051    x = c0;
1052
1053 /* store the second sum [carry] */
1054 #define COMBA_STORE2(x) \
1055    x = c1;
1056
1057 /* anything you need at the end */
1058 #define COMBA_FINI
1059
1060 /* this should multiply i and j  */
1061 #define MULADD(i, j)                                      \
1062 asm(                                                      \
1063      "movl  %6,%%eax     \n\t"                            \
1064      "mull  %7           \n\t"                            \
1065      "addl  %%eax,%0     \n\t"                            \
1066      "adcl  %%edx,%1     \n\t"                            \
1067      "adcl  $0,%2        \n\t"                            \
1068      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%edx","%cc");
1069
1070 #elif defined(TFM_X86_64)
1071 /* x86-64 optimized */
1072
1073 /* anything you need at the start */
1074 #define COMBA_START
1075
1076 /* clear the chaining variables */
1077 #define COMBA_CLEAR \
1078    c0 = c1 = c2 = 0;
1079
1080 /* forward the carry to the next digit */
1081 #define COMBA_FORWARD \
1082    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1083
1084 /* store the first sum */
1085 #define COMBA_STORE(x) \
1086    x = c0;
1087
1088 /* store the second sum [carry] */
1089 #define COMBA_STORE2(x) \
1090    x = c1;
1091
1092 /* anything you need at the end */
1093 #define COMBA_FINI
1094
1095 /* this should multiply i and j  */
1096 #define MULADD(i, j)                                      \
1097 asm  (                                                    \
1098      "movq  %6,%%rax     \n\t"                            \
1099      "mulq  %7           \n\t"                            \
1100      "addq  %%rax,%0     \n\t"                            \
1101      "adcq  %%rdx,%1     \n\t"                            \
1102      "adcq  $0,%2        \n\t"                            \
1103      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j)  :"%rax","%rdx","%cc");
1104
1105 #elif defined(TFM_SSE2)
1106 /* use SSE2 optimizations */
1107
1108 /* anything you need at the start */
1109 #define COMBA_START
1110
1111 /* clear the chaining variables */
1112 #define COMBA_CLEAR \
1113    c0 = c1 = c2 = 0;
1114
1115 /* forward the carry to the next digit */
1116 #define COMBA_FORWARD \
1117    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1118
1119 /* store the first sum */
1120 #define COMBA_STORE(x) \
1121    x = c0;
1122
1123 /* store the second sum [carry] */
1124 #define COMBA_STORE2(x) \
1125    x = c1;
1126
1127 /* anything you need at the end */
1128 #define COMBA_FINI \
1129    asm("emms");
1130
1131 /* this should multiply i and j  */
1132 #define MULADD(i, j)                                     \
1133 asm(                                                     \
1134     "movd  %6,%%mm0     \n\t"                            \
1135     "movd  %7,%%mm1     \n\t"                            \
1136     "pmuludq %%mm1,%%mm0\n\t"                            \
1137     "movd  %%mm0,%%eax  \n\t"                            \
1138     "psrlq $32,%%mm0    \n\t"                            \
1139     "addl  %%eax,%0     \n\t"                            \
1140     "movd  %%mm0,%%eax  \n\t"                            \
1141     "adcl  %%eax,%1     \n\t"                            \
1142     "adcl  $0,%2        \n\t"                            \
1143     :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%cc");
1144
1145 #elif defined(TFM_ARM)
1146 /* ARM code */
1147
1148 #define COMBA_START
1149
1150 #define COMBA_CLEAR \
1151    c0 = c1 = c2 = 0;
1152
1153 #define COMBA_FORWARD \
1154    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1155
1156 #define COMBA_STORE(x) \
1157    x = c0;
1158
1159 #define COMBA_STORE2(x) \
1160    x = c1;
1161
1162 #define COMBA_FINI
1163
1164 #define MULADD(i, j)                                          \
1165 asm(                                                          \
1166 "  UMULL  r0,r1,%6,%7           \n\t"                         \
1167 "  ADDS   %0,%0,r0              \n\t"                         \
1168 "  ADCS   %1,%1,r1              \n\t"                         \
1169 "  ADC    %2,%2,#0              \n\t"                         \
1170 :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "%cc");
1171
1172 #elif defined(TFM_PPC32)
1173 /* For 32-bit PPC */
1174
1175 #define COMBA_START
1176
1177 #define COMBA_CLEAR \
1178    c0 = c1 = c2 = 0;
1179
1180 #define COMBA_FORWARD \
1181    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1182
1183 #define COMBA_STORE(x) \
1184    x = c0;
1185
1186 #define COMBA_STORE2(x) \
1187    x = c1;
1188
1189 #define COMBA_FINI
1190
1191 /* untested: will mulhwu change the flags?  Docs say no */
1192 #define MULADD(i, j)              \
1193 asm(                              \
1194    " mullw  16,%6,%7       \n\t" \
1195    " addc   %0,%0,16       \n\t" \
1196    " mulhwu 16,%6,%7       \n\t" \
1197    " adde   %1,%1,16       \n\t" \
1198    " addze  %2,%2          \n\t" \
1199 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"16");
1200
1201 #elif defined(TFM_PPC64)
1202 /* For 64-bit PPC */
1203
1204 #define COMBA_START
1205
1206 #define COMBA_CLEAR \
1207    c0 = c1 = c2 = 0;
1208
1209 #define COMBA_FORWARD \
1210    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1211
1212 #define COMBA_STORE(x) \
1213    x = c0;
1214
1215 #define COMBA_STORE2(x) \
1216    x = c1;
1217
1218 #define COMBA_FINI
1219
1220 /* untested: will mulhwu change the flags?  Docs say no */
1221 #define MULADD(i, j)              \
1222 asm(                              \
1223    " mulld  16,%6,%7       \n\t" \
1224    " addc   %0,%0,16       \n\t" \
1225    " mulhdu 16,%6,%7       \n\t" \
1226    " adde   %1,%1,16       \n\t" \
1227    " addze  %2,%2          \n\t" \
1228 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"16");
1229
1230 #elif defined(TFM_AVR32)
1231
1232 /* ISO C code */
1233
1234 #define COMBA_START
1235
1236 #define COMBA_CLEAR \
1237    c0 = c1 = c2 = 0;
1238
1239 #define COMBA_FORWARD \
1240    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1241
1242 #define COMBA_STORE(x) \
1243    x = c0;
1244
1245 #define COMBA_STORE2(x) \
1246    x = c1;
1247
1248 #define COMBA_FINI
1249
1250 #define MULADD(i, j)             \
1251 asm(                             \
1252    " mulu.d r2,%6,%7        \n\t"\
1253    " add    %0,r2           \n\t"\
1254    " adc    %1,%1,r3        \n\t"\
1255    " acr    %2              \n\t"\
1256 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r2","r3");
1257
1258 #else
1259 /* ISO C code */
1260
1261 #define COMBA_START
1262
1263 #define COMBA_CLEAR \
1264    c0 = c1 = c2 = 0;
1265
1266 #define COMBA_FORWARD \
1267    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
1268
1269 #define COMBA_STORE(x) \
1270    x = c0;
1271
1272 #define COMBA_STORE2(x) \
1273    x = c1;
1274
1275 #define COMBA_FINI
1276
1277 #define MULADD(i, j)                                                              \
1278    do { fp_word t;                                                                \
1279    t = (fp_word)c0 + ((fp_word)i) * ((fp_word)j); c0 = t;                         \
1280    t = (fp_word)c1 + (t >> DIGIT_BIT);            c1 = t; c2 += t >> DIGIT_BIT;   \
1281    } while (0);
1282
1283 #endif
1284
1285
1286 #ifdef TFM_SMALL_SET
1287 #include "fp_mul_comba_small_set.i"
1288 #include "fp_mul_comba_3.i"
1289 #include "fp_mul_comba_4.i"
1290 #include "fp_mul_comba_6.i"
1291 #include "fp_mul_comba_7.i"
1292 #include "fp_mul_comba_8.i"
1293 #include "fp_mul_comba_9.i"
1294 #include "fp_mul_comba_12.i"
1295 #include "fp_mul_comba_17.i"
1296 #include "fp_mul_comba_20.i"
1297 #include "fp_mul_comba_24.i"
1298 #include "fp_mul_comba_28.i"
1299 #include "fp_mul_comba_32.i"
1300 #include "fp_mul_comba_48.i"
1301 #include "fp_mul_comba_64.i"
1302 #endif
1303
1304 /* end fp_mul_comba.c asm */
1305