crypto/bn/asm/x86_64-mont.pl

   1 #!/usr/bin/env perl
   2
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
   5 # project. The module is, however, dual licensed under OpenSSL and
   6 # CRYPTOGAMS licenses depending on where you obtain it. For further
   7 # details see http://www.openssl.org/~appro/cryptogams/.
   8 # ====================================================================
   9
  10 # October 2005.
  11 #
  12 # Montgomery multiplication routine for x86_64. While it gives modest
  13 # 9% improvement of rsa4096 sign on Opteron, rsa512 sign runs more
  14 # than twice, >2x, as fast. Most common rsa1024 sign is improved by
  15 # respectful 50%. It remains to be seen if loop unrolling and
  16 # dedicated squaring routine can provide further improvement...
  17
  18 # July 2011.
  19 #
  20 # Add dedicated squaring procedure. Performance improvement varies
  21 # from platform to platform, but in average it's ~5%/15%/25%/33%
  22 # for 512-/1024-/2048-/4096-bit RSA *sign* benchmarks respectively.
  23
  24 # August 2011.
  25 #
  26 # Unroll and modulo-schedule inner loops in such manner that they
  27 # are "fallen through" for input lengths of 8, which is critical for
  28 # 1024-bit RSA *sign*. Average performance improvement in comparison
  29 # to *initial* version of this module from 2005 is ~0%/30%/40%/45%
  30 # for 512-/1024-/2048-/4096-bit RSA *sign* benchmarks respectively.
  31
  32 # June 2013.
  33 #
  34 # Optimize reduction in squaring procedure and improve 1024+-bit RSA
  35 # sign performance by 10-16% on Intel Sandy Bridge and later
  36 # (virtually same on non-Intel processors).
  37
  38 # August 2013.
  39 #
  40 # Add MULX/ADOX/ADCX code path.
  41
  42 $flavour = shift;
  43 $output  = shift;
  44 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
  45
  46 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
  47
  48 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  49 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
  50 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
  51 die "can't locate x86_64-xlate.pl";
  52
  53 open OUT,"| \"$^X\" $xlate $flavour $output";
  54 *STDOUT=*OUT;
  55
  56 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
  57                 =~ /GNU assembler version ([2-9]\.[0-9]+)/) {
  58         $addx = ($1>=2.23);
  59 }
  60
  61 if (!$addx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
  62             `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
  63         $addx = ($1>=2.10);
  64 }
  65
  66 if (!$addx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
  67             `ml64 2>&1` =~ /Version ([0-9]+)\./) {
  68         $addx = ($1>=12);
  69 }
  70
  71 if (!$addx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|.*based on LLVM) ([3-9])\.([0-9]+)/) {
  72         my $ver = $2 + $3/100.0;        # 3.1->3.01, 3.10->3.10
  73         $addx = ($ver>=3.03);
  74 }
  75
  76 # int bn_mul_mont(
  77 $rp="%rdi";     # BN_ULONG *rp,
  78 $ap="%rsi";     # const BN_ULONG *ap,
  79 $bp="%rdx";     # const BN_ULONG *bp,
  80 $np="%rcx";     # const BN_ULONG *np,
  81 $n0="%r8";      # const BN_ULONG *n0,
  82 $num="%r9";     # int num);
  83 $lo0="%r10";
  84 $hi0="%r11";
  85 $hi1="%r13";
  86 $i="%r14";
  87 $j="%r15";
  88 $m0="%rbx";
  89 $m1="%rbp";
  90
  91 $code=<<___;
  92 .text
  93
  94 .extern OPENSSL_ia32cap_P
  95
  96 .globl  bn_mul_mont
  97 .type   bn_mul_mont,\@function,6
  98 .align  16
  99 bn_mul_mont:
 100         test    \$3,${num}d
 101         jnz     .Lmul_enter
 102         cmp     \$8,${num}d
 103         jb      .Lmul_enter
 104 ___
 105 $code.=<<___ if ($addx);
 106         mov     OPENSSL_ia32cap_P+8(%rip),%r11d
 107 ___
 108 $code.=<<___;
 109         cmp     $ap,$bp
 110         jne     .Lmul4x_enter
 111         test    \$7,${num}d
 112         jz      .Lsqr8x_enter
 113         jmp     .Lmul4x_enter
 114
 115 .align  16
 116 .Lmul_enter:
 117         push    %rbx
 118         push    %rbp
 119         push    %r12
 120         push    %r13
 121         push    %r14
 122         push    %r15
 123
 124         mov     ${num}d,${num}d
 125         lea     2($num),%r10
 126         mov     %rsp,%r11
 127         neg     %r10
 128         lea     (%rsp,%r10,8),%rsp      # tp=alloca(8*(num+2))
 129         and     \$-1024,%rsp            # minimize TLB usage
 130
 131         mov     %r11,8(%rsp,$num,8)     # tp[num+1]=%rsp
 132 .Lmul_body:
 133         mov     $bp,%r12                # reassign $bp
 134 ___
 135                 $bp="%r12";
 136 $code.=<<___;
 137         mov     ($n0),$n0               # pull n0[0] value
 138         mov     ($bp),$m0               # m0=bp[0]
 139         mov     ($ap),%rax
 140
 141         xor     $i,$i                   # i=0
 142         xor     $j,$j                   # j=0
 143
 144         mov     $n0,$m1
 145         mulq    $m0                     # ap[0]*bp[0]
 146         mov     %rax,$lo0
 147         mov     ($np),%rax
 148
 149         imulq   $lo0,$m1                # "tp[0]"*n0
 150         mov     %rdx,$hi0
 151
 152         mulq    $m1                     # np[0]*m1
 153         add     %rax,$lo0               # discarded
 154         mov     8($ap),%rax
 155         adc     \$0,%rdx
 156         mov     %rdx,$hi1
 157
 158         lea     1($j),$j                # j++
 159         jmp     .L1st_enter
 160
 161 .align  16
 162 .L1st:
 163         add     %rax,$hi1
 164         mov     ($ap,$j,8),%rax
 165         adc     \$0,%rdx
 166         add     $hi0,$hi1               # np[j]*m1+ap[j]*bp[0]
 167         mov     $lo0,$hi0
 168         adc     \$0,%rdx
 169         mov     $hi1,-16(%rsp,$j,8)     # tp[j-1]
 170         mov     %rdx,$hi1
 171
 172 .L1st_enter:
 173         mulq    $m0                     # ap[j]*bp[0]
 174         add     %rax,$hi0
 175         mov     ($np,$j,8),%rax
 176         adc     \$0,%rdx
 177         lea     1($j),$j                # j++
 178         mov     %rdx,$lo0
 179
 180         mulq    $m1                     # np[j]*m1
 181         cmp     $num,$j
 182         jne     .L1st
 183
 184         add     %rax,$hi1
 185         mov     ($ap),%rax              # ap[0]
 186         adc     \$0,%rdx
 187         add     $hi0,$hi1               # np[j]*m1+ap[j]*bp[0]
 188         adc     \$0,%rdx
 189         mov     $hi1,-16(%rsp,$j,8)     # tp[j-1]
 190         mov     %rdx,$hi1
 191         mov     $lo0,$hi0
 192
 193         xor     %rdx,%rdx
 194         add     $hi0,$hi1
 195         adc     \$0,%rdx
 196         mov     $hi1,-8(%rsp,$num,8)
 197         mov     %rdx,(%rsp,$num,8)      # store upmost overflow bit
 198
 199         lea     1($i),$i                # i++
 200         jmp     .Louter
 201 .align  16
 202 .Louter:
 203         mov     ($bp,$i,8),$m0          # m0=bp[i]
 204         xor     $j,$j                   # j=0
 205         mov     $n0,$m1
 206         mov     (%rsp),$lo0
 207         mulq    $m0                     # ap[0]*bp[i]
 208         add     %rax,$lo0               # ap[0]*bp[i]+tp[0]
 209         mov     ($np),%rax
 210         adc     \$0,%rdx
 211
 212         imulq   $lo0,$m1                # tp[0]*n0
 213         mov     %rdx,$hi0
 214
 215         mulq    $m1                     # np[0]*m1
 216         add     %rax,$lo0               # discarded
 217         mov     8($ap),%rax
 218         adc     \$0,%rdx
 219         mov     8(%rsp),$lo0            # tp[1]
 220         mov     %rdx,$hi1
 221
 222         lea     1($j),$j                # j++
 223         jmp     .Linner_enter
 224
 225 .align  16
 226 .Linner:
 227         add     %rax,$hi1
 228         mov     ($ap,$j,8),%rax
 229         adc     \$0,%rdx
 230         add     $lo0,$hi1               # np[j]*m1+ap[j]*bp[i]+tp[j]
 231         mov     (%rsp,$j,8),$lo0
 232         adc     \$0,%rdx
 233         mov     $hi1,-16(%rsp,$j,8)     # tp[j-1]
 234         mov     %rdx,$hi1
 235
 236 .Linner_enter:
 237         mulq    $m0                     # ap[j]*bp[i]
 238         add     %rax,$hi0
 239         mov     ($np,$j,8),%rax
 240         adc     \$0,%rdx
 241         add     $hi0,$lo0               # ap[j]*bp[i]+tp[j]
 242         mov     %rdx,$hi0
 243         adc     \$0,$hi0
 244         lea     1($j),$j                # j++
 245
 246         mulq    $m1                     # np[j]*m1
 247         cmp     $num,$j
 248         jne     .Linner
 249
 250         add     %rax,$hi1
 251         mov     ($ap),%rax              # ap[0]
 252         adc     \$0,%rdx
 253         add     $lo0,$hi1               # np[j]*m1+ap[j]*bp[i]+tp[j]
 254         mov     (%rsp,$j,8),$lo0
 255         adc     \$0,%rdx
 256         mov     $hi1,-16(%rsp,$j,8)     # tp[j-1]
 257         mov     %rdx,$hi1
 258
 259         xor     %rdx,%rdx
 260         add     $hi0,$hi1
 261         adc     \$0,%rdx
 262         add     $lo0,$hi1               # pull upmost overflow bit
 263         adc     \$0,%rdx
 264         mov     $hi1,-8(%rsp,$num,8)
 265         mov     %rdx,(%rsp,$num,8)      # store upmost overflow bit
 266
 267         lea     1($i),$i                # i++
 268         cmp     $num,$i
 269         jb      .Louter
 270
 271         xor     $i,$i                   # i=0 and clear CF!
 272         mov     (%rsp),%rax             # tp[0]
 273         lea     (%rsp),$ap              # borrow ap for tp
 274         mov     $num,$j                 # j=num
 275         jmp     .Lsub
 276 .align  16
 277 .Lsub:  sbb     ($np,$i,8),%rax
 278         mov     %rax,($rp,$i,8)         # rp[i]=tp[i]-np[i]
 279         mov     8($ap,$i,8),%rax        # tp[i+1]
 280         lea     1($i),$i                # i++
 281         dec     $j                      # doesnn't affect CF!
 282         jnz     .Lsub
 283
 284         sbb     \$0,%rax                # handle upmost overflow bit
 285         xor     $i,$i
 286         and     %rax,$ap
 287         not     %rax
 288         mov     $rp,$np
 289         and     %rax,$np
 290         mov     $num,$j                 # j=num
 291         or      $np,$ap                 # ap=borrow?tp:rp
 292 .align  16
 293 .Lcopy:                                 # copy or in-place refresh
 294         mov     ($ap,$i,8),%rax
 295         mov     $i,(%rsp,$i,8)          # zap temporary vector
 296         mov     %rax,($rp,$i,8)         # rp[i]=tp[i]
 297         lea     1($i),$i
 298         sub     \$1,$j
 299         jnz     .Lcopy
 300
 301         mov     8(%rsp,$num,8),%rsi     # restore %rsp
 302         mov     \$1,%rax
 303         mov     (%rsi),%r15
 304         mov     8(%rsi),%r14
 305         mov     16(%rsi),%r13
 306         mov     24(%rsi),%r12
 307         mov     32(%rsi),%rbp
 308         mov     40(%rsi),%rbx
 309         lea     48(%rsi),%rsp
 310 .Lmul_epilogue:
 311         ret
 312 .size   bn_mul_mont,.-bn_mul_mont
 313 ___
 314 {{{
 315 my @A=("%r10","%r11");
 316 my @N=("%r13","%rdi");
 317 $code.=<<___;
 318 .type   bn_mul4x_mont,\@function,6
 319 .align  16
 320 bn_mul4x_mont:
 321 .Lmul4x_enter:
 322 ___
 323 $code.=<<___ if ($addx);
 324         and     \$0x80100,%r11d
 325         cmp     \$0x80100,%r11d
 326         je      .Lmulx4x_enter
 327 ___
 328 $code.=<<___;
 329         push    %rbx
 330         push    %rbp
 331         push    %r12
 332         push    %r13
 333         push    %r14
 334         push    %r15
 335
 336         mov     ${num}d,${num}d
 337         lea     4($num),%r10
 338         mov     %rsp,%r11
 339         neg     %r10
 340         lea     (%rsp,%r10,8),%rsp      # tp=alloca(8*(num+4))
 341         and     \$-1024,%rsp            # minimize TLB usage
 342
 343         mov     %r11,8(%rsp,$num,8)     # tp[num+1]=%rsp
 344 .Lmul4x_body:
 345         mov     $rp,16(%rsp,$num,8)     # tp[num+2]=$rp
 346         mov     %rdx,%r12               # reassign $bp
 347 ___
 348                 $bp="%r12";
 349 $code.=<<___;
 350         mov     ($n0),$n0               # pull n0[0] value
 351         mov     ($bp),$m0               # m0=bp[0]
 352         mov     ($ap),%rax
 353
 354         xor     $i,$i                   # i=0
 355         xor     $j,$j                   # j=0
 356
 357         mov     $n0,$m1
 358         mulq    $m0                     # ap[0]*bp[0]
 359         mov     %rax,$A[0]
 360         mov     ($np),%rax
 361
 362         imulq   $A[0],$m1               # "tp[0]"*n0
 363         mov     %rdx,$A[1]
 364
 365         mulq    $m1                     # np[0]*m1
 366         add     %rax,$A[0]              # discarded
 367         mov     8($ap),%rax
 368         adc     \$0,%rdx
 369         mov     %rdx,$N[1]
 370
 371         mulq    $m0
 372         add     %rax,$A[1]
 373         mov     8($np),%rax
 374         adc     \$0,%rdx
 375         mov     %rdx,$A[0]
 376
 377         mulq    $m1
 378         add     %rax,$N[1]
 379         mov     16($ap),%rax
 380         adc     \$0,%rdx
 381         add     $A[1],$N[1]
 382         lea     4($j),$j                # j++
 383         adc     \$0,%rdx
 384         mov     $N[1],(%rsp)
 385         mov     %rdx,$N[0]
 386         jmp     .L1st4x
 387 .align  16
 388 .L1st4x:
 389         mulq    $m0                     # ap[j]*bp[0]
 390         add     %rax,$A[0]
 391         mov     -16($np,$j,8),%rax
 392         adc     \$0,%rdx
 393         mov     %rdx,$A[1]
 394
 395         mulq    $m1                     # np[j]*m1
 396         add     %rax,$N[0]
 397         mov     -8($ap,$j,8),%rax
 398         adc     \$0,%rdx
 399         add     $A[0],$N[0]             # np[j]*m1+ap[j]*bp[0]
 400         adc     \$0,%rdx
 401         mov     $N[0],-24(%rsp,$j,8)    # tp[j-1]
 402         mov     %rdx,$N[1]
 403
 404         mulq    $m0                     # ap[j]*bp[0]
 405         add     %rax,$A[1]
 406         mov     -8($np,$j,8),%rax
 407         adc     \$0,%rdx
 408         mov     %rdx,$A[0]
 409
 410         mulq    $m1                     # np[j]*m1
 411         add     %rax,$N[1]
 412         mov     ($ap,$j,8),%rax
 413         adc     \$0,%rdx
 414         add     $A[1],$N[1]             # np[j]*m1+ap[j]*bp[0]
 415         adc     \$0,%rdx
 416         mov     $N[1],-16(%rsp,$j,8)    # tp[j-1]
 417         mov     %rdx,$N[0]
 418
 419         mulq    $m0                     # ap[j]*bp[0]
 420         add     %rax,$A[0]
 421         mov     ($np,$j,8),%rax
 422         adc     \$0,%rdx
 423         mov     %rdx,$A[1]
 424
 425         mulq    $m1                     # np[j]*m1
 426         add     %rax,$N[0]
 427         mov     8($ap,$j,8),%rax
 428         adc     \$0,%rdx
 429         add     $A[0],$N[0]             # np[j]*m1+ap[j]*bp[0]
 430         adc     \$0,%rdx
 431         mov     $N[0],-8(%rsp,$j,8)     # tp[j-1]
 432         mov     %rdx,$N[1]
 433
 434         mulq    $m0                     # ap[j]*bp[0]
 435         add     %rax,$A[1]
 436         mov     8($np,$j,8),%rax
 437         adc     \$0,%rdx
 438         lea     4($j),$j                # j++
 439         mov     %rdx,$A[0]
 440
 441         mulq    $m1                     # np[j]*m1
 442         add     %rax,$N[1]
 443         mov     -16($ap,$j,8),%rax
 444         adc     \$0,%rdx
 445         add     $A[1],$N[1]             # np[j]*m1+ap[j]*bp[0]
 446         adc     \$0,%rdx
 447         mov     $N[1],-32(%rsp,$j,8)    # tp[j-1]
 448         mov     %rdx,$N[0]
 449         cmp     $num,$j
 450         jb      .L1st4x
 451
 452         mulq    $m0                     # ap[j]*bp[0]
 453         add     %rax,$A[0]
 454         mov     -16($np,$j,8),%rax
 455         adc     \$0,%rdx
 456         mov     %rdx,$A[1]
 457
 458         mulq    $m1                     # np[j]*m1
 459         add     %rax,$N[0]
 460         mov     -8($ap,$j,8),%rax
 461         adc     \$0,%rdx
 462         add     $A[0],$N[0]             # np[j]*m1+ap[j]*bp[0]
 463         adc     \$0,%rdx
 464         mov     $N[0],-24(%rsp,$j,8)    # tp[j-1]
 465         mov     %rdx,$N[1]
 466
 467         mulq    $m0                     # ap[j]*bp[0]
 468         add     %rax,$A[1]
 469         mov     -8($np,$j,8),%rax
 470         adc     \$0,%rdx
 471         mov     %rdx,$A[0]
 472
 473         mulq    $m1                     # np[j]*m1
 474         add     %rax,$N[1]
 475         mov     ($ap),%rax              # ap[0]
 476         adc     \$0,%rdx
 477         add     $A[1],$N[1]             # np[j]*m1+ap[j]*bp[0]
 478         adc     \$0,%rdx
 479         mov     $N[1],-16(%rsp,$j,8)    # tp[j-1]
 480         mov     %rdx,$N[0]
 481
 482         xor     $N[1],$N[1]
 483         add     $A[0],$N[0]
 484         adc     \$0,$N[1]
 485         mov     $N[0],-8(%rsp,$j,8)
 486         mov     $N[1],(%rsp,$j,8)       # store upmost overflow bit
 487
 488         lea     1($i),$i                # i++
 489 .align  4
 490 .Louter4x:
 491         mov     ($bp,$i,8),$m0          # m0=bp[i]
 492         xor     $j,$j                   # j=0
 493         mov     (%rsp),$A[0]
 494         mov     $n0,$m1
 495         mulq    $m0                     # ap[0]*bp[i]
 496         add     %rax,$A[0]              # ap[0]*bp[i]+tp[0]
 497         mov     ($np),%rax
 498         adc     \$0,%rdx
 499
 500         imulq   $A[0],$m1               # tp[0]*n0
 501         mov     %rdx,$A[1]
 502
 503         mulq    $m1                     # np[0]*m1
 504         add     %rax,$A[0]              # "$N[0]", discarded
 505         mov     8($ap),%rax
 506         adc     \$0,%rdx
 507         mov     %rdx,$N[1]
 508
 509         mulq    $m0                     # ap[j]*bp[i]
 510         add     %rax,$A[1]
 511         mov     8($np),%rax
 512         adc     \$0,%rdx
 513         add     8(%rsp),$A[1]           # +tp[1]
 514         adc     \$0,%rdx
 515         mov     %rdx,$A[0]
 516
 517         mulq    $m1                     # np[j]*m1
 518         add     %rax,$N[1]
 519         mov     16($ap),%rax
 520         adc     \$0,%rdx
 521         add     $A[1],$N[1]             # np[j]*m1+ap[j]*bp[i]+tp[j]
 522         lea     4($j),$j                # j+=2
 523         adc     \$0,%rdx
 524         mov     $N[1],(%rsp)            # tp[j-1]
 525         mov     %rdx,$N[0]
 526         jmp     .Linner4x
 527 .align  16
 528 .Linner4x:
 529         mulq    $m0                     # ap[j]*bp[i]
 530         add     %rax,$A[0]
 531         mov     -16($np,$j,8),%rax
 532         adc     \$0,%rdx
 533         add     -16(%rsp,$j,8),$A[0]    # ap[j]*bp[i]+tp[j]
 534         adc     \$0,%rdx
 535         mov     %rdx,$A[1]
 536
 537         mulq    $m1                     # np[j]*m1
 538         add     %rax,$N[0]
 539         mov     -8($ap,$j,8),%rax
 540         adc     \$0,%rdx
 541         add     $A[0],$N[0]
 542         adc     \$0,%rdx
 543         mov     $N[0],-24(%rsp,$j,8)    # tp[j-1]
 544         mov     %rdx,$N[1]
 545
 546         mulq    $m0                     # ap[j]*bp[i]
 547         add     %rax,$A[1]
 548         mov     -8($np,$j,8),%rax
 549         adc     \$0,%rdx
 550         add     -8(%rsp,$j,8),$A[1]
 551         adc     \$0,%rdx
 552         mov     %rdx,$A[0]
 553
 554         mulq    $m1                     # np[j]*m1
 555         add     %rax,$N[1]
 556         mov     ($ap,$j,8),%rax
 557         adc     \$0,%rdx
 558         add     $A[1],$N[1]
 559         adc     \$0,%rdx
 560         mov     $N[1],-16(%rsp,$j,8)    # tp[j-1]
 561         mov     %rdx,$N[0]
 562
 563         mulq    $m0                     # ap[j]*bp[i]
 564         add     %rax,$A[0]
 565         mov     ($np,$j,8),%rax
 566         adc     \$0,%rdx
 567         add     (%rsp,$j,8),$A[0]       # ap[j]*bp[i]+tp[j]
 568         adc     \$0,%rdx
 569         mov     %rdx,$A[1]
 570
 571         mulq    $m1                     # np[j]*m1
 572         add     %rax,$N[0]
 573         mov     8($ap,$j,8),%rax
 574         adc     \$0,%rdx
 575         add     $A[0],$N[0]
 576         adc     \$0,%rdx
 577         mov     $N[0],-8(%rsp,$j,8)     # tp[j-1]
 578         mov     %rdx,$N[1]
 579
 580         mulq    $m0                     # ap[j]*bp[i]
 581         add     %rax,$A[1]
 582         mov     8($np,$j,8),%rax
 583         adc     \$0,%rdx
 584         add     8(%rsp,$j,8),$A[1]
 585         adc     \$0,%rdx
 586         lea     4($j),$j                # j++
 587         mov     %rdx,$A[0]
 588
 589         mulq    $m1                     # np[j]*m1
 590         add     %rax,$N[1]
 591         mov     -16($ap,$j,8),%rax
 592         adc     \$0,%rdx
 593         add     $A[1],$N[1]
 594         adc     \$0,%rdx
 595         mov     $N[1],-32(%rsp,$j,8)    # tp[j-1]
 596         mov     %rdx,$N[0]
 597         cmp     $num,$j
 598         jb      .Linner4x
 599
 600         mulq    $m0                     # ap[j]*bp[i]
 601         add     %rax,$A[0]
 602         mov     -16($np,$j,8),%rax
 603         adc     \$0,%rdx
 604         add     -16(%rsp,$j,8),$A[0]    # ap[j]*bp[i]+tp[j]
 605         adc     \$0,%rdx
 606         mov     %rdx,$A[1]
 607
 608         mulq    $m1                     # np[j]*m1
 609         add     %rax,$N[0]
 610         mov     -8($ap,$j,8),%rax
 611         adc     \$0,%rdx
 612         add     $A[0],$N[0]
 613         adc     \$0,%rdx
 614         mov     $N[0],-24(%rsp,$j,8)    # tp[j-1]
 615         mov     %rdx,$N[1]
 616
 617         mulq    $m0                     # ap[j]*bp[i]
 618         add     %rax,$A[1]
 619         mov     -8($np,$j,8),%rax
 620         adc     \$0,%rdx
 621         add     -8(%rsp,$j,8),$A[1]
 622         adc     \$0,%rdx
 623         lea     1($i),$i                # i++
 624         mov     %rdx,$A[0]
 625
 626         mulq    $m1                     # np[j]*m1
 627         add     %rax,$N[1]
 628         mov     ($ap),%rax              # ap[0]
 629         adc     \$0,%rdx
 630         add     $A[1],$N[1]
 631         adc     \$0,%rdx
 632         mov     $N[1],-16(%rsp,$j,8)    # tp[j-1]
 633         mov     %rdx,$N[0]
 634
 635         xor     $N[1],$N[1]
 636         add     $A[0],$N[0]
 637         adc     \$0,$N[1]
 638         add     (%rsp,$num,8),$N[0]     # pull upmost overflow bit
 639         adc     \$0,$N[1]
 640         mov     $N[0],-8(%rsp,$j,8)
 641         mov     $N[1],(%rsp,$j,8)       # store upmost overflow bit
 642
 643         cmp     $num,$i
 644         jb      .Louter4x
 645 ___
 646 {
 647 my @ri=("%rax","%rdx",$m0,$m1);
 648 $code.=<<___;
 649         mov     16(%rsp,$num,8),$rp     # restore $rp
 650         mov     0(%rsp),@ri[0]          # tp[0]
 651         pxor    %xmm0,%xmm0
 652         mov     8(%rsp),@ri[1]          # tp[1]
 653         shr     \$2,$num                # num/=4
 654         lea     (%rsp),$ap              # borrow ap for tp
 655         xor     $i,$i                   # i=0 and clear CF!
 656
 657         sub     0($np),@ri[0]
 658         mov     16($ap),@ri[2]          # tp[2]
 659         mov     24($ap),@ri[3]          # tp[3]
 660         sbb     8($np),@ri[1]
 661         lea     -1($num),$j             # j=num/4-1
 662         jmp     .Lsub4x
 663 .align  16
 664 .Lsub4x:
 665         mov     @ri[0],0($rp,$i,8)      # rp[i]=tp[i]-np[i]
 666         mov     @ri[1],8($rp,$i,8)      # rp[i]=tp[i]-np[i]
 667         sbb     16($np,$i,8),@ri[2]
 668         mov     32($ap,$i,8),@ri[0]     # tp[i+1]
 669         mov     40($ap,$i,8),@ri[1]
 670         sbb     24($np,$i,8),@ri[3]
 671         mov     @ri[2],16($rp,$i,8)     # rp[i]=tp[i]-np[i]
 672         mov     @ri[3],24($rp,$i,8)     # rp[i]=tp[i]-np[i]
 673         sbb     32($np,$i,8),@ri[0]
 674         mov     48($ap,$i,8),@ri[2]
 675         mov     56($ap,$i,8),@ri[3]
 676         sbb     40($np,$i,8),@ri[1]
 677         lea     4($i),$i                # i++
 678         dec     $j                      # doesnn't affect CF!
 679         jnz     .Lsub4x
 680
 681         mov     @ri[0],0($rp,$i,8)      # rp[i]=tp[i]-np[i]
 682         mov     32($ap,$i,8),@ri[0]     # load overflow bit
 683         sbb     16($np,$i,8),@ri[2]
 684         mov     @ri[1],8($rp,$i,8)      # rp[i]=tp[i]-np[i]
 685         sbb     24($np,$i,8),@ri[3]
 686         mov     @ri[2],16($rp,$i,8)     # rp[i]=tp[i]-np[i]
 687
 688         sbb     \$0,@ri[0]              # handle upmost overflow bit
 689         mov     @ri[3],24($rp,$i,8)     # rp[i]=tp[i]-np[i]
 690         xor     $i,$i                   # i=0
 691         and     @ri[0],$ap
 692         not     @ri[0]
 693         mov     $rp,$np
 694         and     @ri[0],$np
 695         lea     -1($num),$j
 696         or      $np,$ap                 # ap=borrow?tp:rp
 697
 698         movdqu  ($ap),%xmm1
 699         movdqa  %xmm0,(%rsp)
 700         movdqu  %xmm1,($rp)
 701         jmp     .Lcopy4x
 702 .align  16
 703 .Lcopy4x:                                       # copy or in-place refresh
 704         movdqu  16($ap,$i),%xmm2
 705         movdqu  32($ap,$i),%xmm1
 706         movdqa  %xmm0,16(%rsp,$i)
 707         movdqu  %xmm2,16($rp,$i)
 708         movdqa  %xmm0,32(%rsp,$i)
 709         movdqu  %xmm1,32($rp,$i)
 710         lea     32($i),$i
 711         dec     $j
 712         jnz     .Lcopy4x
 713
 714         shl     \$2,$num
 715         movdqu  16($ap,$i),%xmm2
 716         movdqa  %xmm0,16(%rsp,$i)
 717         movdqu  %xmm2,16($rp,$i)
 718 ___
 719 }
 720 $code.=<<___;
 721         mov     8(%rsp,$num,8),%rsi     # restore %rsp
 722         mov     \$1,%rax
 723         mov     (%rsi),%r15
 724         mov     8(%rsi),%r14
 725         mov     16(%rsi),%r13
 726         mov     24(%rsi),%r12
 727         mov     32(%rsi),%rbp
 728         mov     40(%rsi),%rbx
 729         lea     48(%rsi),%rsp
 730 .Lmul4x_epilogue:
 731         ret
 732 .size   bn_mul4x_mont,.-bn_mul4x_mont
 733 ___
 734 }}}
 735 \f{{{
 736 ######################################################################
 737 # void bn_sqr8x_mont(
 738 my $rptr="%rdi";        # const BN_ULONG *rptr,
 739 my $aptr="%rsi";        # const BN_ULONG *aptr,
 740 my $bptr="%rdx";        # not used
 741 my $nptr="%rcx";        # const BN_ULONG *nptr,
 742 my $n0  ="%r8";         # const BN_ULONG *n0);
 743 my $num ="%r9";         # int num, has to be divisible by 8
 744
 745 my ($i,$j,$tptr)=("%rbp","%rcx",$rptr);
 746 my @A0=("%r10","%r11");
 747 my @A1=("%r12","%r13");
 748 my ($a0,$a1,$ai)=("%r14","%r15","%rbx");
 749
 750 $code.=<<___    if ($addx);
 751 .extern bn_sqrx8x_internal              # see x86_64-mont5 module
 752 ___
 753 $code.=<<___;
 754 .extern bn_sqr8x_internal               # see x86_64-mont5 module
 755
 756 .type   bn_sqr8x_mont,\@function,6
 757 .align  32
 758 bn_sqr8x_mont:
 759 .Lsqr8x_enter:
 760         mov     %rsp,%rax
 761         push    %rbx
 762         push    %rbp
 763         push    %r12
 764         push    %r13
 765         push    %r14
 766         push    %r15
 767
 768         mov     ${num}d,%r10d
 769         shl     \$3,${num}d             # convert $num to bytes
 770         shl     \$3+2,%r10              # 4*$num
 771         neg     $num
 772
 773         ##############################################################
 774         # ensure that stack frame doesn't alias with $aptr modulo
 775         # 4096. this is done to allow memory disambiguation logic
 776         # do its job.
 777         #
 778         lea     -64(%rsp,$num,2),%r11
 779         mov     ($n0),$n0               # *n0
 780         sub     $aptr,%r11
 781         and     \$4095,%r11
 782         cmp     %r11,%r10
 783         jb      .Lsqr8x_sp_alt
 784         sub     %r11,%rsp               # align with $aptr
 785         lea     -64(%rsp,$num,2),%rsp   # alloca(frame+2*$num)
 786         jmp     .Lsqr8x_sp_done
 787
 788 .align  32
 789 .Lsqr8x_sp_alt:
 790         lea     4096-64(,$num,2),%r10   # 4096-frame-2*$num
 791         lea     -64(%rsp,$num,2),%rsp   # alloca(frame+2*$num)
 792         sub     %r10,%r11
 793         mov     \$0,%r10
 794         cmovc   %r10,%r11
 795         sub     %r11,%rsp
 796 .Lsqr8x_sp_done:
 797         and     \$-64,%rsp
 798         mov     $num,%r10
 799         neg     $num
 800
 801         mov     $n0,  32(%rsp)
 802         mov     %rax, 40(%rsp)          # save original %rsp
 803 .Lsqr8x_body:
 804
 805         movq    $nptr, %xmm2            # save pointer to modulus
 806         pxor    %xmm0,%xmm0
 807         movq    $rptr,%xmm1             # save $rptr
 808         movq    %r10, %xmm3             # -$num
 809 ___
 810 $code.=<<___ if ($addx);
 811         mov     OPENSSL_ia32cap_P+8(%rip),%eax
 812         and     \$0x80100,%eax
 813         cmp     \$0x80100,%eax
 814         jne     .Lsqr8x_nox
 815
 816         call    bn_sqrx8x_internal      # see x86_64-mont5 module
 817
 818         pxor    %xmm0,%xmm0
 819         lea     48(%rsp),%rax
 820         shr     \$3+2,$num
 821         mov     40(%rsp),%rsi           # restore %rsp
 822         jmp     .Lsqr8x_zero
 823
 824 .align  32
 825 .Lsqr8x_nox:
 826 ___
 827 $code.=<<___;
 828         call    bn_sqr8x_internal       # see x86_64-mont5 module
 829
 830         pxor    %xmm0,%xmm0
 831         lea     48(%rsp),%rax
 832         shr     \$3+2,$num
 833         mov     40(%rsp),%rsi           # restore %rsp
 834         jmp     .Lsqr8x_zero
 835
 836 .align  32
 837 .Lsqr8x_zero:
 838         movdqa  %xmm0,16*0(%rax)        # wipe t
 839         movdqa  %xmm0,16*1(%rax)
 840         movdqa  %xmm0,16*2(%rax)
 841         movdqa  %xmm0,16*3(%rax)
 842         lea     16*4(%rax),%rax
 843         dec     $num
 844         jnz     .Lsqr8x_zero
 845
 846         mov     \$1,%rax
 847         mov     -48(%rsi),%r15
 848         mov     -40(%rsi),%r14
 849         mov     -32(%rsi),%r13
 850         mov     -24(%rsi),%r12
 851         mov     -16(%rsi),%rbp
 852         mov     -8(%rsi),%rbx
 853         lea     (%rsi),%rsp
 854 .Lsqr8x_epilogue:
 855         ret
 856 .size   bn_sqr8x_mont,.-bn_sqr8x_mont
 857 ___
 858 }}}
 859 \f
 860 if ($addx) {{{
 861 my $bp="%rdx";  # original value
 862
 863 $code.=<<___;
 864 .type   bn_mulx4x_mont,\@function,6
 865 .align  32
 866 bn_mulx4x_mont:
 867 .Lmulx4x_enter:
 868         mov     %rsp,%rax
 869         push    %rbx
 870         push    %rbp
 871         push    %r12
 872         push    %r13
 873         push    %r14
 874         push    %r15
 875
 876         shl     \$3,${num}d             # convert $num to bytes
 877         .byte   0x67
 878         xor     %r10,%r10
 879         sub     $num,%r10               # -$num
 880         mov     ($n0),$n0               # *n0
 881         lea     -72(%rsp,%r10),%rsp     # alloca(frame+$num+8)
 882         lea     ($bp,$num),%r10
 883         and     \$-128,%rsp
 884         ##############################################################
 885         # Stack layout
 886         # +0    num
 887         # +8    off-loaded &b[i]
 888         # +16   end of b[num]
 889         # +24   saved n0
 890         # +32   saved rp
 891         # +40   saved %rsp
 892         # +48   inner counter
 893         # +56
 894         # +64   tmp[num+1]
 895         #
 896         mov     $num,0(%rsp)            # save $num
 897         shr     \$5,$num
 898         mov     %r10,16(%rsp)           # end of b[num]
 899         sub     \$1,$num
 900         mov     $n0, 24(%rsp)           # save *n0
 901         mov     $rp, 32(%rsp)           # save $rp
 902         mov     %rax,40(%rsp)           # save original %rsp
 903         mov     $num,48(%rsp)           # inner counter
 904         jmp     .Lmulx4x_body
 905
 906 .align  32
 907 .Lmulx4x_body:
 908 ___
 909 my ($aptr, $bptr, $nptr, $tptr, $mi,  $bi,  $zero, $num)=
 910    ("%rsi","%rdi","%rcx","%rbx","%r8","%r9","%rbp","%rax");
 911 my $rptr=$bptr;
 912 $code.=<<___;
 913         lea     8($bp),$bptr
 914         mov     ($bp),%rdx              # b[0], $bp==%rdx actually
 915         lea     64+32(%rsp),$tptr
 916         mov     %rdx,$bi
 917
 918         mulx    0*8($aptr),$mi,%rax     # a[0]*b[0]
 919         mulx    1*8($aptr),%r11,%r14    # a[1]*b[0]
 920         add     %rax,%r11
 921         mov     $bptr,8(%rsp)           # off-load &b[i]
 922         mulx    2*8($aptr),%r12,%r13    # ...
 923         adc     %r14,%r12
 924         adc     \$0,%r13
 925
 926         mov     $mi,$bptr               # borrow $bptr
 927         imulq   24(%rsp),$mi            # "t[0]"*n0
 928         xor     $zero,$zero             # cf=0, of=0
 929
 930         mulx    3*8($aptr),%rax,%r14
 931          mov    $mi,%rdx
 932         lea     4*8($aptr),$aptr
 933         adcx    %rax,%r13
 934         adcx    $zero,%r14              # cf=0
 935
 936         mulx    0*8($nptr),%rax,%r10
 937         adcx    %rax,$bptr              # discarded
 938         adox    %r11,%r10
 939         mulx    1*8($nptr),%rax,%r11
 940         adcx    %rax,%r10
 941         adox    %r12,%r11
 942         .byte   0xc4,0x62,0xfb,0xf6,0xa1,0x10,0x00,0x00,0x00    # mulx  2*8($nptr),%rax,%r12
 943         mov     48(%rsp),$bptr          # counter value
 944         mov     %r10,-4*8($tptr)
 945         adcx    %rax,%r11
 946         adox    %r13,%r12
 947         mulx    3*8($nptr),%rax,%r15
 948          mov    $bi,%rdx
 949         mov     %r11,-3*8($tptr)
 950         adcx    %rax,%r12
 951         adox    $zero,%r15              # of=0
 952         lea     4*8($nptr),$nptr
 953         mov     %r12,-2*8($tptr)
 954
 955         jmp     .Lmulx4x_1st
 956
 957 .align  32
 958 .Lmulx4x_1st:
 959         adcx    $zero,%r15              # cf=0, modulo-scheduled
 960         mulx    0*8($aptr),%r10,%rax    # a[4]*b[0]
 961         adcx    %r14,%r10
 962         mulx    1*8($aptr),%r11,%r14    # a[5]*b[0]
 963         adcx    %rax,%r11
 964         mulx    2*8($aptr),%r12,%rax    # ...
 965         adcx    %r14,%r12
 966         mulx    3*8($aptr),%r13,%r14
 967          .byte  0x67,0x67
 968          mov    $mi,%rdx
 969         adcx    %rax,%r13
 970         adcx    $zero,%r14              # cf=0
 971         lea     4*8($aptr),$aptr
 972         lea     4*8($tptr),$tptr
 973
 974         adox    %r15,%r10
 975         mulx    0*8($nptr),%rax,%r15
 976         adcx    %rax,%r10
 977         adox    %r15,%r11
 978         mulx    1*8($nptr),%rax,%r15
 979         adcx    %rax,%r11
 980         adox    %r15,%r12
 981         mulx    2*8($nptr),%rax,%r15
 982         mov     %r10,-5*8($tptr)
 983         adcx    %rax,%r12
 984         mov     %r11,-4*8($tptr)
 985         adox    %r15,%r13
 986         mulx    3*8($nptr),%rax,%r15
 987          mov    $bi,%rdx
 988         mov     %r12,-3*8($tptr)
 989         adcx    %rax,%r13
 990         adox    $zero,%r15
 991         lea     4*8($nptr),$nptr
 992         mov     %r13,-2*8($tptr)
 993
 994         dec     $bptr                   # of=0, pass cf
 995         jnz     .Lmulx4x_1st
 996
 997         mov     0(%rsp),$num            # load num
 998         mov     8(%rsp),$bptr           # re-load &b[i]
 999         adc     $zero,%r15              # modulo-scheduled
1000         add     %r15,%r14
1001         sbb     %r15,%r15               # top-most carry
1002         mov     %r14,-1*8($tptr)
1003         jmp     .Lmulx4x_outer
1004
1005 .align  32
1006 .Lmulx4x_outer:
1007         mov     ($bptr),%rdx            # b[i]
1008         lea     8($bptr),$bptr          # b++
1009         sub     $num,$aptr              # rewind $aptr
1010         mov     %r15,($tptr)            # save top-most carry
1011         lea     64+4*8(%rsp),$tptr
1012         sub     $num,$nptr              # rewind $nptr
1013
1014         mulx    0*8($aptr),$mi,%r11     # a[0]*b[i]
1015         xor     %ebp,%ebp               # xor   $zero,$zero     # cf=0, of=0
1016         mov     %rdx,$bi
1017         mulx    1*8($aptr),%r14,%r12    # a[1]*b[i]
1018         adox    -4*8($tptr),$mi
1019         adcx    %r14,%r11
1020         mulx    2*8($aptr),%r15,%r13    # ...
1021         adox    -3*8($tptr),%r11
1022         adcx    %r15,%r12
1023         adox    $zero,%r12
1024         adcx    $zero,%r13
1025
1026         mov     $bptr,8(%rsp)           # off-load &b[i]
1027         .byte   0x67
1028         mov     $mi,%r15
1029         imulq   24(%rsp),$mi            # "t[0]"*n0
1030         xor     %ebp,%ebp               # xor   $zero,$zero     # cf=0, of=0
1031
1032         mulx    3*8($aptr),%rax,%r14
1033          mov    $mi,%rdx
1034         adox    -2*8($tptr),%r12
1035         adcx    %rax,%r13
1036         adox    -1*8($tptr),%r13
1037         adcx    $zero,%r14
1038         lea     4*8($aptr),$aptr
1039         adox    $zero,%r14
1040
1041         mulx    0*8($nptr),%rax,%r10
1042         adcx    %rax,%r15               # discarded
1043         adox    %r11,%r10
1044         mulx    1*8($nptr),%rax,%r11
1045         adcx    %rax,%r10
1046         adox    %r12,%r11
1047         mulx    2*8($nptr),%rax,%r12
1048         mov     %r10,-4*8($tptr)
1049         adcx    %rax,%r11
1050         adox    %r13,%r12
1051         mulx    3*8($nptr),%rax,%r15
1052          mov    $bi,%rdx
1053         mov     %r11,-3*8($tptr)
1054         lea     4*8($nptr),$nptr
1055         adcx    %rax,%r12
1056         adox    $zero,%r15              # of=0
1057         mov     48(%rsp),$bptr          # counter value
1058         mov     %r12,-2*8($tptr)
1059
1060         jmp     .Lmulx4x_inner
1061
1062 .align  32
1063 .Lmulx4x_inner:
1064         mulx    0*8($aptr),%r10,%rax    # a[4]*b[i]
1065         adcx    $zero,%r15              # cf=0, modulo-scheduled
1066         adox    %r14,%r10
1067         mulx    1*8($aptr),%r11,%r14    # a[5]*b[i]
1068         adcx    0*8($tptr),%r10
1069         adox    %rax,%r11
1070         mulx    2*8($aptr),%r12,%rax    # ...
1071         adcx    1*8($tptr),%r11
1072         adox    %r14,%r12
1073         mulx    3*8($aptr),%r13,%r14
1074          mov    $mi,%rdx
1075         adcx    2*8($tptr),%r12
1076         adox    %rax,%r13
1077         adcx    3*8($tptr),%r13
1078         adox    $zero,%r14              # of=0
1079         lea     4*8($aptr),$aptr
1080         lea     4*8($tptr),$tptr
1081         adcx    $zero,%r14              # cf=0
1082
1083         adox    %r15,%r10
1084         mulx    0*8($nptr),%rax,%r15
1085         adcx    %rax,%r10
1086         adox    %r15,%r11
1087         mulx    1*8($nptr),%rax,%r15
1088         adcx    %rax,%r11
1089         adox    %r15,%r12
1090         mulx    2*8($nptr),%rax,%r15
1091         mov     %r10,-5*8($tptr)
1092         adcx    %rax,%r12
1093         adox    %r15,%r13
1094         mulx    3*8($nptr),%rax,%r15
1095          mov    $bi,%rdx
1096         mov     %r11,-4*8($tptr)
1097         mov     %r12,-3*8($tptr)
1098         adcx    %rax,%r13
1099         adox    $zero,%r15
1100         lea     4*8($nptr),$nptr
1101         mov     %r13,-2*8($tptr)
1102
1103         dec     $bptr                   # of=0, pass cf
1104         jnz     .Lmulx4x_inner
1105
1106         mov     0(%rsp),$num            # load num
1107         mov     8(%rsp),$bptr           # re-load &b[i]
1108         adc     $zero,%r15              # modulo-scheduled
1109         sub     0*8($tptr),$zero        # pull top-most carry
1110         adc     %r15,%r14
1111         mov     -8($nptr),$mi
1112         sbb     %r15,%r15               # top-most carry
1113         mov     %r14,-1*8($tptr)
1114
1115         cmp     16(%rsp),$bptr
1116         jne     .Lmulx4x_outer
1117
1118         sub     %r14,$mi                # compare top-most words
1119         sbb     $mi,$mi
1120         or      $mi,%r15
1121
1122         neg     $num
1123         xor     %rdx,%rdx
1124         mov     32(%rsp),$rptr          # restore rp
1125         lea     64(%rsp),$tptr
1126
1127         pxor    %xmm0,%xmm0
1128         mov     0*8($nptr,$num),%r8
1129         mov     1*8($nptr,$num),%r9
1130         neg     %r8
1131         jmp     .Lmulx4x_sub_entry
1132
1133 .align  32
1134 .Lmulx4x_sub:
1135         mov     0*8($nptr,$num),%r8
1136         mov     1*8($nptr,$num),%r9
1137         not     %r8
1138 .Lmulx4x_sub_entry:
1139         mov     2*8($nptr,$num),%r10
1140         not     %r9
1141         and     %r15,%r8
1142         mov     3*8($nptr,$num),%r11
1143         not     %r10
1144         and     %r15,%r9
1145         not     %r11
1146         and     %r15,%r10
1147         and     %r15,%r11
1148
1149         neg     %rdx                    # mov %rdx,%cf
1150         adc     0*8($tptr),%r8
1151         adc     1*8($tptr),%r9
1152         movdqa  %xmm0,($tptr)
1153         adc     2*8($tptr),%r10
1154         adc     3*8($tptr),%r11
1155         movdqa  %xmm0,16($tptr)
1156         lea     4*8($tptr),$tptr
1157         sbb     %rdx,%rdx               # mov %cf,%rdx
1158
1159         mov     %r8,0*8($rptr)
1160         mov     %r9,1*8($rptr)
1161         mov     %r10,2*8($rptr)
1162         mov     %r11,3*8($rptr)
1163         lea     4*8($rptr),$rptr
1164
1165         add     \$32,$num
1166         jnz     .Lmulx4x_sub
1167
1168         mov     40(%rsp),%rsi           # restore %rsp
1169         mov     \$1,%rax
1170         mov     -48(%rsi),%r15
1171         mov     -40(%rsi),%r14
1172         mov     -32(%rsi),%r13
1173         mov     -24(%rsi),%r12
1174         mov     -16(%rsi),%rbp
1175         mov     -8(%rsi),%rbx
1176         lea     (%rsi),%rsp
1177 .Lmulx4x_epilogue:
1178         ret
1179 .size   bn_mulx4x_mont,.-bn_mulx4x_mont
1180 ___
1181 }}}
1182 $code.=<<___;
1183 .asciz  "Montgomery Multiplication for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
1184 .align  16
1185 ___
1186
1187 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
1188 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
1189 if ($win64) {
1190 $rec="%rcx";
1191 $frame="%rdx";
1192 $context="%r8";
1193 $disp="%r9";
1194
1195 $code.=<<___;
1196 .extern __imp_RtlVirtualUnwind
1197 .type   mul_handler,\@abi-omnipotent
1198 .align  16
1199 mul_handler:
1200         push    %rsi
1201         push    %rdi
1202         push    %rbx
1203         push    %rbp
1204         push    %r12
1205         push    %r13
1206         push    %r14
1207         push    %r15
1208         pushfq
1209         sub     \$64,%rsp
1210
1211         mov     120($context),%rax      # pull context->Rax
1212         mov     248($context),%rbx      # pull context->Rip
1213
1214         mov     8($disp),%rsi           # disp->ImageBase
1215         mov     56($disp),%r11          # disp->HandlerData
1216
1217         mov     0(%r11),%r10d           # HandlerData[0]
1218         lea     (%rsi,%r10),%r10        # end of prologue label
1219         cmp     %r10,%rbx               # context->Rip<end of prologue label
1220         jb      .Lcommon_seh_tail
1221
1222         mov     152($context),%rax      # pull context->Rsp
1223
1224         mov     4(%r11),%r10d           # HandlerData[1]
1225         lea     (%rsi,%r10),%r10        # epilogue label
1226         cmp     %r10,%rbx               # context->Rip>=epilogue label
1227         jae     .Lcommon_seh_tail
1228
1229         mov     192($context),%r10      # pull $num
1230         mov     8(%rax,%r10,8),%rax     # pull saved stack pointer
1231         lea     48(%rax),%rax
1232
1233         mov     -8(%rax),%rbx
1234         mov     -16(%rax),%rbp
1235         mov     -24(%rax),%r12
1236         mov     -32(%rax),%r13
1237         mov     -40(%rax),%r14
1238         mov     -48(%rax),%r15
1239         mov     %rbx,144($context)      # restore context->Rbx
1240         mov     %rbp,160($context)      # restore context->Rbp
1241         mov     %r12,216($context)      # restore context->R12
1242         mov     %r13,224($context)      # restore context->R13
1243         mov     %r14,232($context)      # restore context->R14
1244         mov     %r15,240($context)      # restore context->R15
1245
1246         jmp     .Lcommon_seh_tail
1247 .size   mul_handler,.-mul_handler
1248
1249 .type   sqr_handler,\@abi-omnipotent
1250 .align  16
1251 sqr_handler:
1252         push    %rsi
1253         push    %rdi
1254         push    %rbx
1255         push    %rbp
1256         push    %r12
1257         push    %r13
1258         push    %r14
1259         push    %r15
1260         pushfq
1261         sub     \$64,%rsp
1262
1263         mov     120($context),%rax      # pull context->Rax
1264         mov     248($context),%rbx      # pull context->Rip
1265
1266         mov     8($disp),%rsi           # disp->ImageBase
1267         mov     56($disp),%r11          # disp->HandlerData
1268
1269         mov     0(%r11),%r10d           # HandlerData[0]
1270         lea     (%rsi,%r10),%r10        # end of prologue label
1271         cmp     %r10,%rbx               # context->Rip<.Lsqr_body
1272         jb      .Lcommon_seh_tail
1273
1274         mov     152($context),%rax      # pull context->Rsp
1275
1276         mov     4(%r11),%r10d           # HandlerData[1]
1277         lea     (%rsi,%r10),%r10        # epilogue label
1278         cmp     %r10,%rbx               # context->Rip>=.Lsqr_epilogue
1279         jae     .Lcommon_seh_tail
1280
1281         mov     40(%rax),%rax           # pull saved stack pointer
1282
1283         mov     -8(%rax),%rbx
1284         mov     -16(%rax),%rbp
1285         mov     -24(%rax),%r12
1286         mov     -32(%rax),%r13
1287         mov     -40(%rax),%r14
1288         mov     -48(%rax),%r15
1289         mov     %rbx,144($context)      # restore context->Rbx
1290         mov     %rbp,160($context)      # restore context->Rbp
1291         mov     %r12,216($context)      # restore context->R12
1292         mov     %r13,224($context)      # restore context->R13
1293         mov     %r14,232($context)      # restore context->R14
1294         mov     %r15,240($context)      # restore context->R15
1295
1296 .Lcommon_seh_tail:
1297         mov     8(%rax),%rdi
1298         mov     16(%rax),%rsi
1299         mov     %rax,152($context)      # restore context->Rsp
1300         mov     %rsi,168($context)      # restore context->Rsi
1301         mov     %rdi,176($context)      # restore context->Rdi
1302
1303         mov     40($disp),%rdi          # disp->ContextRecord
1304         mov     $context,%rsi           # context
1305         mov     \$154,%ecx              # sizeof(CONTEXT)
1306         .long   0xa548f3fc              # cld; rep movsq
1307
1308         mov     $disp,%rsi
1309         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
1310         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
1311         mov     0(%rsi),%r8             # arg3, disp->ControlPc
1312         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
1313         mov     40(%rsi),%r10           # disp->ContextRecord
1314         lea     56(%rsi),%r11           # &disp->HandlerData
1315         lea     24(%rsi),%r12           # &disp->EstablisherFrame
1316         mov     %r10,32(%rsp)           # arg5
1317         mov     %r11,40(%rsp)           # arg6
1318         mov     %r12,48(%rsp)           # arg7
1319         mov     %rcx,56(%rsp)           # arg8, (NULL)
1320         call    *__imp_RtlVirtualUnwind(%rip)
1321
1322         mov     \$1,%eax                # ExceptionContinueSearch
1323         add     \$64,%rsp
1324         popfq
1325         pop     %r15
1326         pop     %r14
1327         pop     %r13
1328         pop     %r12
1329         pop     %rbp
1330         pop     %rbx
1331         pop     %rdi
1332         pop     %rsi
1333         ret
1334 .size   sqr_handler,.-sqr_handler
1335
1336 .section        .pdata
1337 .align  4
1338         .rva    .LSEH_begin_bn_mul_mont
1339         .rva    .LSEH_end_bn_mul_mont
1340         .rva    .LSEH_info_bn_mul_mont
1341
1342         .rva    .LSEH_begin_bn_mul4x_mont
1343         .rva    .LSEH_end_bn_mul4x_mont
1344         .rva    .LSEH_info_bn_mul4x_mont
1345
1346         .rva    .LSEH_begin_bn_sqr8x_mont
1347         .rva    .LSEH_end_bn_sqr8x_mont
1348         .rva    .LSEH_info_bn_sqr8x_mont
1349 ___
1350 $code.=<<___ if ($addx);
1351         .rva    .LSEH_begin_bn_mulx4x_mont
1352         .rva    .LSEH_end_bn_mulx4x_mont
1353         .rva    .LSEH_info_bn_mulx4x_mont
1354 ___
1355 $code.=<<___;
1356 .section        .xdata
1357 .align  8
1358 .LSEH_info_bn_mul_mont:
1359         .byte   9,0,0,0
1360         .rva    mul_handler
1361         .rva    .Lmul_body,.Lmul_epilogue       # HandlerData[]
1362 .LSEH_info_bn_mul4x_mont:
1363         .byte   9,0,0,0
1364         .rva    mul_handler
1365         .rva    .Lmul4x_body,.Lmul4x_epilogue   # HandlerData[]
1366 .LSEH_info_bn_sqr8x_mont:
1367         .byte   9,0,0,0
1368         .rva    sqr_handler
1369         .rva    .Lsqr8x_body,.Lsqr8x_epilogue   # HandlerData[]
1370 ___
1371 $code.=<<___ if ($addx);
1372 .LSEH_info_bn_mulx4x_mont:
1373         .byte   9,0,0,0
1374         .rva    sqr_handler
1375         .rva    .Lmulx4x_body,.Lmulx4x_epilogue # HandlerData[]
1376 ___
1377 }
1378
1379 print $code;
1380 close STDOUT;