pd.if.org Git - zpackage/blob - tomsfastmath/src/sqr/fp_sqr_comba.c

   1 /*
   2  *
   3  * This project is meant to fill in where LibTomMath
   4  * falls short.  That is speed ;-)
   5  *
   6  * This project is public domain and free for all purposes.
   7  *
   8  * Tom St Denis, tomstdenis@gmail.com
   9  */
  10 #include <tfm_private.h>
  11
  12 #if defined(TFM_PRESCOTT) && defined(TFM_SSE2)
  13    #undef TFM_SSE2
  14    #define TFM_X86
  15 #endif
  16
  17 #if defined(TFM_X86)
  18
  19 /* x86-32 optimized */
  20
  21 #define COMBA_START
  22
  23 #define CLEAR_CARRY \
  24    c0 = c1 = c2 = 0;
  25
  26 #define COMBA_STORE(x) \
  27    x = c0;
  28
  29 #define COMBA_STORE2(x) \
  30    x = c1;
  31
  32 #define CARRY_FORWARD \
  33    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
  34
  35 #define COMBA_FINI
  36
  37 #define SQRADD(i, j)                                      \
  38 asm(                                            \
  39      "movl  %6,%%eax     \n\t"                            \
  40      "mull  %%eax        \n\t"                            \
  41      "addl  %%eax,%0     \n\t"                            \
  42      "adcl  %%edx,%1     \n\t"                            \
  43      "adcl  $0,%2        \n\t"                            \
  44      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i) :"%eax","%edx","cc");
  45
  46 #define SQRADD2(i, j)                                     \
  47 asm(                                            \
  48      "movl  %6,%%eax     \n\t"                            \
  49      "mull  %7           \n\t"                            \
  50      "addl  %%eax,%0     \n\t"                            \
  51      "adcl  %%edx,%1     \n\t"                            \
  52      "adcl  $0,%2        \n\t"                            \
  53      "addl  %%eax,%0     \n\t"                            \
  54      "adcl  %%edx,%1     \n\t"                            \
  55      "adcl  $0,%2        \n\t"                            \
  56      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%edx","cc");
  57
  58 #define SQRADDSC(i, j)                                    \
  59 asm(                                                     \
  60      "movl  %3,%%eax     \n\t"                            \
  61      "mull  %4           \n\t"                            \
  62      "movl  %%eax,%0     \n\t"                            \
  63      "movl  %%edx,%1     \n\t"                            \
  64      "xorl  %2,%2        \n\t"                            \
  65      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%eax","%edx","cc");
  66
  67 #define SQRADDAC(i, j)                                    \
  68 asm(                                                     \
  69      "movl  %6,%%eax     \n\t"                            \
  70      "mull  %7           \n\t"                            \
  71      "addl  %%eax,%0     \n\t"                            \
  72      "adcl  %%edx,%1     \n\t"                            \
  73      "adcl  $0,%2        \n\t"                            \
  74      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%eax","%edx","cc");
  75
  76 #define SQRADDDB                                          \
  77 asm(                                                     \
  78      "addl %6,%0         \n\t"                            \
  79      "adcl %7,%1         \n\t"                            \
  80      "adcl %8,%2         \n\t"                            \
  81      "addl %6,%0         \n\t"                            \
  82      "adcl %7,%1         \n\t"                            \
  83      "adcl %8,%2         \n\t"                            \
  84      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "cc");
  85
  86 #elif defined(TFM_X86_64)
  87 /* x86-64 optimized */
  88
  89 #define COMBA_START
  90
  91 #define CLEAR_CARRY \
  92    c0 = c1 = c2 = 0;
  93
  94 #define COMBA_STORE(x) \
  95    x = c0;
  96
  97 #define COMBA_STORE2(x) \
  98    x = c1;
  99
 100 #define CARRY_FORWARD \
 101    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 102
 103 #define COMBA_FINI
 104
 105 #define SQRADD(i, j)                                      \
 106 asm(                                                     \
 107      "movq  %6,%%rax     \n\t"                            \
 108      "mulq  %%rax        \n\t"                            \
 109      "addq  %%rax,%0     \n\t"                            \
 110      "adcq  %%rdx,%1     \n\t"                            \
 111      "adcq  $0,%2        \n\t"                            \
 112      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "x"(i) :"%rax","%rdx","cc");
 113
 114 #define SQRADD2(i, j)                                     \
 115 asm(                                                     \
 116      "movq  %6,%%rax     \n\t"                            \
 117      "mulq  %7           \n\t"                            \
 118      "addq  %%rax,%0     \n\t"                            \
 119      "adcq  %%rdx,%1     \n\t"                            \
 120      "adcq  $0,%2        \n\t"                            \
 121      "addq  %%rax,%0     \n\t"                            \
 122      "adcq  %%rdx,%1     \n\t"                            \
 123      "adcq  $0,%2        \n\t"                            \
 124      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "g"(i), "g"(j)  :"%rax","%rdx","cc");
 125
 126 #define SQRADDSC(i, j)                                    \
 127 asm(                                                     \
 128      "movq  %3,%%rax     \n\t"                            \
 129      "mulq  %4           \n\t"                            \
 130      "movq  %%rax,%0     \n\t"                            \
 131      "movq  %%rdx,%1     \n\t"                            \
 132      "xorq  %2,%2        \n\t"                            \
 133      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "g"(i), "g"(j) :"%rax","%rdx","cc");
 134
 135 #define SQRADDAC(i, j)                                                         \
 136 asm(                                                     \
 137      "movq  %6,%%rax     \n\t"                            \
 138      "mulq  %7           \n\t"                            \
 139      "addq  %%rax,%0     \n\t"                            \
 140      "adcq  %%rdx,%1     \n\t"                            \
 141      "adcq  $0,%2        \n\t"                            \
 142      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "g"(i), "g"(j) :"%rax","%rdx","cc");
 143
 144 #define SQRADDDB                                          \
 145 asm(                                                     \
 146      "addq %6,%0         \n\t"                            \
 147      "adcq %7,%1         \n\t"                            \
 148      "adcq %8,%2         \n\t"                            \
 149      "addq %6,%0         \n\t"                            \
 150      "adcq %7,%1         \n\t"                            \
 151      "adcq %8,%2         \n\t"                            \
 152      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "cc");
 153
 154 #elif defined(TFM_SSE2)
 155
 156 /* SSE2 Optimized */
 157 #define COMBA_START
 158
 159 #define CLEAR_CARRY \
 160    c0 = c1 = c2 = 0;
 161
 162 #define COMBA_STORE(x) \
 163    x = c0;
 164
 165 #define COMBA_STORE2(x) \
 166    x = c1;
 167
 168 #define CARRY_FORWARD \
 169    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 170
 171 #define COMBA_FINI \
 172    asm("emms");
 173
 174 #define SQRADD(i, j)                                      \
 175 asm(                                            \
 176      "movd  %6,%%mm0     \n\t"                            \
 177      "pmuludq %%mm0,%%mm0\n\t"                            \
 178      "movd  %%mm0,%%eax  \n\t"                            \
 179      "psrlq $32,%%mm0    \n\t"                            \
 180      "addl  %%eax,%0     \n\t"                            \
 181      "movd  %%mm0,%%eax  \n\t"                            \
 182      "adcl  %%eax,%1     \n\t"                            \
 183      "adcl  $0,%2        \n\t"                            \
 184      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i) :"%eax","cc");
 185
 186 #define SQRADD2(i, j)                                     \
 187 asm(                                            \
 188      "movd  %6,%%mm0     \n\t"                            \
 189      "movd  %7,%%mm1     \n\t"                            \
 190      "pmuludq %%mm1,%%mm0\n\t"                            \
 191      "movd  %%mm0,%%eax  \n\t"                            \
 192      "psrlq $32,%%mm0    \n\t"                            \
 193      "movd  %%mm0,%%edx  \n\t"                            \
 194      "addl  %%eax,%0     \n\t"                            \
 195      "adcl  %%edx,%1     \n\t"                            \
 196      "adcl  $0,%2        \n\t"                            \
 197      "addl  %%eax,%0     \n\t"                            \
 198      "adcl  %%edx,%1     \n\t"                            \
 199      "adcl  $0,%2        \n\t"                            \
 200      :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j)  :"%eax","%edx","cc");
 201
 202 #define SQRADDSC(i, j)                                                         \
 203 asm(                                            \
 204      "movd  %6,%%mm0     \n\t"                            \
 205      "movd  %7,%%mm1     \n\t"                            \
 206      "pmuludq %%mm1,%%mm0\n\t"                            \
 207      "movd  %%mm0,%0     \n\t"                            \
 208      "psrlq $32,%%mm0    \n\t"                            \
 209      "movd  %%mm0,%1     \n\t"                            \
 210      "xorl  %2,%2        \n\t"                            \
 211      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j));
 212
 213 #define SQRADDAC(i, j)                                                         \
 214 asm(                                            \
 215      "movd  %6,%%mm0     \n\t"                            \
 216      "movd  %7,%%mm1     \n\t"                            \
 217      "pmuludq %%mm1,%%mm0\n\t"                            \
 218      "movd  %%mm0,%%eax  \n\t"                            \
 219      "psrlq $32,%%mm0    \n\t"                            \
 220      "movd  %%mm0,%%edx  \n\t"                            \
 221      "addl  %%eax,%0     \n\t"                            \
 222      "adcl  %%edx,%1     \n\t"                            \
 223      "adcl  $0,%2        \n\t"                            \
 224      :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j)  :"%eax","%edx","cc");
 225
 226 #define SQRADDDB                                          \
 227 asm(                                                     \
 228      "addl %6,%0         \n\t"                            \
 229      "adcl %7,%1         \n\t"                            \
 230      "adcl %8,%2         \n\t"                            \
 231      "addl %6,%0         \n\t"                            \
 232      "adcl %7,%1         \n\t"                            \
 233      "adcl %8,%2         \n\t"                            \
 234      :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "cc");
 235
 236 #elif defined(TFM_ARM)
 237
 238 /* ARM code */
 239
 240 #define COMBA_START
 241
 242 #define CLEAR_CARRY \
 243    c0 = c1 = c2 = 0;
 244
 245 #define COMBA_STORE(x) \
 246    x = c0;
 247
 248 #define COMBA_STORE2(x) \
 249    x = c1;
 250
 251 #define CARRY_FORWARD \
 252    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 253
 254 #define COMBA_FINI
 255
 256 /* multiplies point i and j, updates carry "c1" and digit c2 */
 257 #define SQRADD(i, j)                                             \
 258 asm(                                                             \
 259 "  UMULL  r0,r1,%6,%6              \n\t"                         \
 260 "  ADDS   %0,%0,r0                 \n\t"                         \
 261 "  ADCS   %1,%1,r1                 \n\t"                         \
 262 "  ADC    %2,%2,#0                 \n\t"                         \
 263 :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i) : "r0", "r1", "cc");
 264
 265 /* for squaring some of the terms are doubled... */
 266 #define SQRADD2(i, j)                                            \
 267 asm(                                                             \
 268 "  UMULL  r0,r1,%6,%7              \n\t"                         \
 269 "  ADDS   %0,%0,r0                 \n\t"                         \
 270 "  ADCS   %1,%1,r1                 \n\t"                         \
 271 "  ADC    %2,%2,#0                 \n\t"                         \
 272 "  ADDS   %0,%0,r0                 \n\t"                         \
 273 "  ADCS   %1,%1,r1                 \n\t"                         \
 274 "  ADC    %2,%2,#0                 \n\t"                         \
 275 :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "cc");
 276
 277 #define SQRADDSC(i, j)                                           \
 278 asm(                                                             \
 279 "  UMULL  %0,%1,%6,%7              \n\t"                         \
 280 "  SUB    %2,%2,%2                 \n\t"                         \
 281 :"=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j) : "cc");
 282
 283 #define SQRADDAC(i, j)                                           \
 284 asm(                                                             \
 285 "  UMULL  r0,r1,%6,%7              \n\t"                         \
 286 "  ADDS   %0,%0,r0                 \n\t"                         \
 287 "  ADCS   %1,%1,r1                 \n\t"                         \
 288 "  ADC    %2,%2,#0                 \n\t"                         \
 289 :"=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j) : "r0", "r1", "cc");
 290
 291 #define SQRADDDB                                                 \
 292 asm(                                                             \
 293 "  ADDS  %0,%0,%3                     \n\t"                      \
 294 "  ADCS  %1,%1,%4                     \n\t"                      \
 295 "  ADC   %2,%2,%5                     \n\t"                      \
 296 "  ADDS  %0,%0,%3                     \n\t"                      \
 297 "  ADCS  %1,%1,%4                     \n\t"                      \
 298 "  ADC   %2,%2,%5                     \n\t"                      \
 299 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "cc");
 300
 301 #elif defined(TFM_PPC32)
 302
 303 /* PPC32 */
 304
 305 #define COMBA_START
 306
 307 #define CLEAR_CARRY \
 308    c0 = c1 = c2 = 0;
 309
 310 #define COMBA_STORE(x) \
 311    x = c0;
 312
 313 #define COMBA_STORE2(x) \
 314    x = c1;
 315
 316 #define CARRY_FORWARD \
 317    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 318
 319 #define COMBA_FINI
 320
 321 /* multiplies point i and j, updates carry "c1" and digit c2 */
 322 #define SQRADD(i, j)             \
 323 asm(                             \
 324    " mullw  16,%6,%6       \n\t" \
 325    " addc   %0,%0,16       \n\t" \
 326    " mulhwu 16,%6,%6       \n\t" \
 327    " adde   %1,%1,16       \n\t" \
 328    " addze  %2,%2          \n\t" \
 329 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"16","cc");
 330
 331 /* for squaring some of the terms are doubled... */
 332 #define SQRADD2(i, j)            \
 333 asm(                             \
 334    " mullw  16,%6,%7       \n\t" \
 335    " mulhwu 17,%6,%7       \n\t" \
 336    " addc   %0,%0,16       \n\t" \
 337    " adde   %1,%1,17       \n\t" \
 338    " addze  %2,%2          \n\t" \
 339    " addc   %0,%0,16       \n\t" \
 340    " adde   %1,%1,17       \n\t" \
 341    " addze  %2,%2          \n\t" \
 342 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"16", "17","cc");
 343
 344 #define SQRADDSC(i, j)            \
 345 asm(                              \
 346    " mullw  %0,%6,%7        \n\t" \
 347    " mulhwu %1,%6,%7        \n\t" \
 348    " xor    %2,%2,%2        \n\t" \
 349 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "cc");
 350
 351 #define SQRADDAC(i, j)           \
 352 asm(                             \
 353    " mullw  16,%6,%7       \n\t" \
 354    " addc   %0,%0,16       \n\t" \
 355    " mulhwu 16,%6,%7       \n\t" \
 356    " adde   %1,%1,16       \n\t" \
 357    " addze  %2,%2          \n\t" \
 358 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"16", "cc");
 359
 360 #define SQRADDDB                  \
 361 asm(                              \
 362    " addc   %0,%0,%3        \n\t" \
 363    " adde   %1,%1,%4        \n\t" \
 364    " adde   %2,%2,%5        \n\t" \
 365    " addc   %0,%0,%3        \n\t" \
 366    " adde   %1,%1,%4        \n\t" \
 367    " adde   %2,%2,%5        \n\t" \
 368 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "cc");
 369
 370 #elif defined(TFM_PPC64)
 371 /* PPC64 */
 372
 373 #define COMBA_START
 374
 375 #define CLEAR_CARRY \
 376    c0 = c1 = c2 = 0;
 377
 378 #define COMBA_STORE(x) \
 379    x = c0;
 380
 381 #define COMBA_STORE2(x) \
 382    x = c1;
 383
 384 #define CARRY_FORWARD \
 385    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 386
 387 #define COMBA_FINI
 388
 389 /* multiplies point i and j, updates carry "c1" and digit c2 */
 390 #define SQRADD(i, j)             \
 391 asm(                             \
 392    " mulld  r16,%6,%6       \n\t" \
 393    " addc   %0,%0,r16       \n\t" \
 394    " mulhdu r16,%6,%6       \n\t" \
 395    " adde   %1,%1,r16       \n\t" \
 396    " addze  %2,%2          \n\t" \
 397 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"r16","cc");
 398
 399 /* for squaring some of the terms are doubled... */
 400 #define SQRADD2(i, j)            \
 401 asm(                             \
 402    " mulld  r16,%6,%7       \n\t" \
 403    " mulhdu r17,%6,%7       \n\t" \
 404    " addc   %0,%0,r16       \n\t" \
 405    " adde   %1,%1,r17       \n\t" \
 406    " addze  %2,%2          \n\t" \
 407    " addc   %0,%0,r16       \n\t" \
 408    " adde   %1,%1,r17       \n\t" \
 409    " addze  %2,%2          \n\t" \
 410 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r16", "r17","cc");
 411
 412 #define SQRADDSC(i, j)            \
 413 asm(                              \
 414    " mulld  %0,%6,%7        \n\t" \
 415    " mulhdu %1,%6,%7        \n\t" \
 416    " xor    %2,%2,%2        \n\t" \
 417 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "cc");
 418
 419 #define SQRADDAC(i, j)           \
 420 asm(                             \
 421    " mulld  r16,%6,%7       \n\t" \
 422    " addc   %0,%0,r16       \n\t" \
 423    " mulhdu r16,%6,%7       \n\t" \
 424    " adde   %1,%1,r16       \n\t" \
 425    " addze  %2,%2          \n\t" \
 426 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"r16", "cc");
 427
 428 #define SQRADDDB                  \
 429 asm(                              \
 430    " addc   %0,%0,%3        \n\t" \
 431    " adde   %1,%1,%4        \n\t" \
 432    " adde   %2,%2,%5        \n\t" \
 433    " addc   %0,%0,%3        \n\t" \
 434    " adde   %1,%1,%4        \n\t" \
 435    " adde   %2,%2,%5        \n\t" \
 436 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "cc");
 437
 438
 439 #elif defined(TFM_AVR32)
 440
 441 /* AVR32 */
 442
 443 #define COMBA_START
 444
 445 #define CLEAR_CARRY \
 446    c0 = c1 = c2 = 0;
 447
 448 #define COMBA_STORE(x) \
 449    x = c0;
 450
 451 #define COMBA_STORE2(x) \
 452    x = c1;
 453
 454 #define CARRY_FORWARD \
 455    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 456
 457 #define COMBA_FINI
 458
 459 /* multiplies point i and j, updates carry "c1" and digit c2 */
 460 #define SQRADD(i, j)             \
 461 asm(                             \
 462    " mulu.d r2,%6,%6       \n\t" \
 463    " add    %0,%0,r2       \n\t" \
 464    " adc    %1,%1,r3       \n\t" \
 465    " acr    %2             \n\t" \
 466 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"r2","r3");
 467
 468 /* for squaring some of the terms are doubled... */
 469 #define SQRADD2(i, j)            \
 470 asm(                             \
 471    " mulu.d r2,%6,%7       \n\t" \
 472    " add    %0,%0,r2       \n\t" \
 473    " adc    %1,%1,r3       \n\t" \
 474    " acr    %2,            \n\t" \
 475    " add    %0,%0,r2       \n\t" \
 476    " adc    %1,%1,r3       \n\t" \
 477    " acr    %2,            \n\t" \
 478 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r2", "r3");
 479
 480 #define SQRADDSC(i, j)            \
 481 asm(                              \
 482    " mulu.d r2,%6,%7        \n\t" \
 483    " mov    %0,r2           \n\t" \
 484    " mov    %1,r3           \n\t" \
 485    " eor    %2,%2           \n\t" \
 486 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "r2", "r3");
 487
 488 #define SQRADDAC(i, j)           \
 489 asm(                             \
 490    " mulu.d r2,%6,%7       \n\t" \
 491    " add    %0,%0,r2       \n\t" \
 492    " adc    %1,%1,r3       \n\t" \
 493    " acr    %2             \n\t" \
 494 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"r2", "r3");
 495
 496 #define SQRADDDB                  \
 497 asm(                              \
 498    " add    %0,%0,%3        \n\t" \
 499    " adc    %1,%1,%4        \n\t" \
 500    " adc    %2,%2,%5        \n\t" \
 501    " add    %0,%0,%3        \n\t" \
 502    " adc    %1,%1,%4        \n\t" \
 503    " adc    %2,%2,%5        \n\t" \
 504 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "cc");
 505
 506 #elif defined(TFM_MIPS)
 507
 508 /* MIPS */
 509
 510 #define COMBA_START
 511
 512 #define CLEAR_CARRY \
 513    c0 = c1 = c2 = 0;
 514
 515 #define COMBA_STORE(x) \
 516    x = c0;
 517
 518 #define COMBA_STORE2(x) \
 519    x = c1;
 520
 521 #define CARRY_FORWARD \
 522    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 523
 524 #define COMBA_FINI
 525
 526 /* multiplies point i and j, updates carry "c1" and digit c2 */
 527 #define SQRADD(i, j)              \
 528 asm(                              \
 529    " multu  %6,%6          \n\t"  \
 530    " mflo   $12            \n\t"  \
 531    " mfhi   $13            \n\t"  \
 532    " addu    %0,%0,$12     \n\t"  \
 533    " sltu   $12,%0,$12     \n\t"  \
 534    " addu    %1,%1,$13     \n\t"  \
 535    " sltu   $13,%1,$13     \n\t"  \
 536    " addu    %1,%1,$12     \n\t"  \
 537    " sltu   $12,%1,$12     \n\t"  \
 538    " addu    %2,%2,$13     \n\t"  \
 539    " addu    %2,%2,$12     \n\t"  \
 540 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"$12","$13");
 541
 542 /* for squaring some of the terms are doubled... */
 543 #define SQRADD2(i, j)            \
 544 asm(                             \
 545    " multu  %6,%7          \n\t" \
 546    " mflo   $12            \n\t" \
 547    " mfhi   $13            \n\t" \
 548                                  \
 549    " addu    %0,%0,$12     \n\t" \
 550    " sltu   $14,%0,$12     \n\t" \
 551    " addu    %1,%1,$13     \n\t" \
 552    " sltu   $15,%1,$13     \n\t" \
 553    " addu    %1,%1,$14     \n\t" \
 554    " sltu   $14,%1,$14     \n\t" \
 555    " addu    %2,%2,$15     \n\t" \
 556    " addu    %2,%2,$14     \n\t" \
 557                                  \
 558    " addu    %0,%0,$12     \n\t" \
 559    " sltu   $14,%0,$12     \n\t" \
 560    " addu    %1,%1,$13     \n\t" \
 561    " sltu   $15,%1,$13     \n\t" \
 562    " addu    %1,%1,$14     \n\t" \
 563    " sltu   $14,%1,$14     \n\t" \
 564    " addu    %2,%2,$15     \n\t" \
 565    " addu    %2,%2,$14     \n\t" \
 566 :"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"$12", "$13", "$14", "$15");
 567
 568 #define SQRADDSC(i, j)            \
 569 asm(                              \
 570    " multu  %6,%7          \n\t"  \
 571    " mflo   %0             \n\t"  \
 572    " mfhi   %1             \n\t"  \
 573    " xor    %2,%2,%2       \n\t"  \
 574 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "cc");
 575
 576 #define SQRADDAC(i, j)           \
 577 asm(                             \
 578    " multu  %6,%7          \n\t" \
 579    " mflo   $12            \n\t" \
 580    " mfhi   $13            \n\t" \
 581    " addu    %0,%0,$12     \n\t" \
 582    " sltu   $12,%0,$12     \n\t" \
 583    " addu    %1,%1,$13     \n\t" \
 584    " sltu   $13,%1,$13     \n\t" \
 585    " addu    %1,%1,$12     \n\t" \
 586    " sltu   $12,%1,$12     \n\t" \
 587    " addu    %2,%2,$13     \n\t" \
 588    " addu    %2,%2,$12     \n\t" \
 589 :"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"$12", "$13", "$14");
 590
 591 #define SQRADDDB                  \
 592 asm(                              \
 593    " addu    %0,%0,%3       \n\t" \
 594    " sltu   $10,%0,%3       \n\t" \
 595    " addu    %1,%1,$10      \n\t" \
 596    " sltu   $10,%1,$10      \n\t" \
 597    " addu    %1,%1,%4       \n\t" \
 598    " sltu   $11,%1,%4       \n\t" \
 599    " addu    %2,%2,$10      \n\t" \
 600    " addu    %2,%2,$11      \n\t" \
 601    " addu    %2,%2,%5       \n\t" \
 602                                   \
 603    " addu    %0,%0,%3       \n\t" \
 604    " sltu   $10,%0,%3       \n\t" \
 605    " addu    %1,%1,$10      \n\t" \
 606    " sltu   $10,%1,$10      \n\t" \
 607    " addu    %1,%1,%4       \n\t" \
 608    " sltu   $11,%1,%4       \n\t" \
 609    " addu    %2,%2,$10      \n\t" \
 610    " addu    %2,%2,$11      \n\t" \
 611    " addu    %2,%2,%5       \n\t" \
 612 :"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "$10", "$11");
 613
 614 #else
 615
 616 #define TFM_ISO
 617
 618 /* ISO C portable code */
 619
 620 #define COMBA_START
 621
 622 #define CLEAR_CARRY \
 623    c0 = c1 = c2 = 0;
 624
 625 #define COMBA_STORE(x) \
 626    x = c0;
 627
 628 #define COMBA_STORE2(x) \
 629    x = c1;
 630
 631 #define CARRY_FORWARD \
 632    do { c0 = c1; c1 = c2; c2 = 0; } while (0);
 633
 634 #define COMBA_FINI
 635
 636 /* multiplies point i and j, updates carry "c1" and digit c2 */
 637 #define SQRADD(i, j)                                 \
 638    do { fp_word t;                                   \
 639    t = c0 + ((fp_word)i) * ((fp_word)j);  c0 = t;    \
 640    t = c1 + (t >> DIGIT_BIT);             c1 = t; c2 += t >> DIGIT_BIT; \
 641    } while (0);
 642
 643
 644 /* for squaring some of the terms are doubled... */
 645 #define SQRADD2(i, j)                                                 \
 646    do { fp_word t;                                                    \
 647    t  = ((fp_word)i) * ((fp_word)j);                                  \
 648    tt = (fp_word)c0 + t;                 c0 = tt;                              \
 649    tt = (fp_word)c1 + (tt >> DIGIT_BIT); c1 = tt; c2 += tt >> DIGIT_BIT;       \
 650    tt = (fp_word)c0 + t;                 c0 = tt;                              \
 651    tt = (fp_word)c1 + (tt >> DIGIT_BIT); c1 = tt; c2 += tt >> DIGIT_BIT;       \
 652    } while (0);
 653
 654 #define SQRADDSC(i, j)                                                         \
 655    do { fp_word t;                                                             \
 656       t =  ((fp_word)i) * ((fp_word)j);                                        \
 657       sc0 = (fp_digit)t; sc1 = (t >> DIGIT_BIT); sc2 = 0;                      \
 658    } while (0);
 659
 660 #define SQRADDAC(i, j)                                                         \
 661    do { fp_word t;                                                             \
 662    t = sc0 + ((fp_word)i) * ((fp_word)j);  sc0 = t;                            \
 663    t = sc1 + (t >> DIGIT_BIT);             sc1 = t; sc2 += t >> DIGIT_BIT;     \
 664    } while (0);
 665
 666 #define SQRADDDB                                                               \
 667    do { fp_word t;                                                             \
 668    t = ((fp_word)sc0) + ((fp_word)sc0) + c0; c0 = t;                                                 \
 669    t = ((fp_word)sc1) + ((fp_word)sc1) + c1 + (t >> DIGIT_BIT); c1 = t;                              \
 670    c2 = c2 + ((fp_word)sc2) + ((fp_word)sc2) + (t >> DIGIT_BIT);                                     \
 671    } while (0);
 672
 673 #endif
 674
 675 /* $Source$ */
 676 /* $Revision$ */
 677 /* $Date$ */