crypto/bn/asm/rsaz-x86_64.pl

   1 #!/usr/bin/env perl
   2
   3 ##############################################################################
   4 #                                                                            #
   5 #  Copyright (c) 2012, Intel Corporation                                     #
   6 #                                                                            #
   7 #  All rights reserved.                                                      #
   8 #                                                                            #
   9 #  Redistribution and use in source and binary forms, with or without        #
  10 #  modification, are permitted provided that the following conditions are    #
  11 #  met:                                                                      #
  12 #                                                                            #
  13 #  *  Redistributions of source code must retain the above copyright         #
  14 #     notice, this list of conditions and the following disclaimer.          #
  15 #                                                                            #
  16 #  *  Redistributions in binary form must reproduce the above copyright      #
  17 #     notice, this list of conditions and the following disclaimer in the    #
  18 #     documentation and/or other materials provided with the                 #
  19 #     distribution.                                                          #
  20 #                                                                            #
  21 #  *  Neither the name of the Intel Corporation nor the names of its         #
  22 #     contributors may be used to endorse or promote products derived from   #
  23 #     this software without specific prior written permission.               #
  24 #                                                                            #
  25 #                                                                            #
  26 #  THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY          #
  27 #  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE         #
  28 #  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        #
  29 #  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR            #
  30 #  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
  31 #  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       #
  32 #  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        #
  33 #  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    #
  34 #  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      #
  35 #  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        #
  36 #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              #
  37 #                                                                            #
  38 ##############################################################################
  39 # Developers and authors:                                                    #
  40 # Shay Gueron (1, 2), and Vlad Krasnov (1)                                   #
  41 # (1) Intel Architecture Group, Microprocessor and Chipset Development,      #
  42 #     Israel Development Center, Haifa, Israel                               #
  43 # (2) University of Haifa                                                    #
  44 ##############################################################################
  45 # Reference:                                                                 #
  46 # [1] S. Gueron, "Efficient Software Implementations of Modular              #
  47 #     Exponentiation", http://eprint.iacr.org/2011/239                       #
  48 # [2] S. Gueron, V. Krasnov. "Speeding up Big-Numbers Squaring".             #
  49 #     IEEE Proceedings of 9th International Conference on Information        #
  50 #     Technology: New Generations (ITNG 2012), 821-823 (2012).               #
  51 # [3] S. Gueron, Efficient Software Implementations of Modular Exponentiation#
  52 #     Journal of Cryptographic Engineering 2:31-43 (2012).                   #
  53 # [4] S. Gueron, V. Krasnov: "[PATCH] Efficient and side channel analysis    #
  54 #     resistant 512-bit and 1024-bit modular exponentiation for optimizing   #
  55 #     RSA1024 and RSA2048 on x86_64 platforms",                              #
  56 #     http://rt.openssl.org/Ticket/Display.html?id=2582&user=guest&pass=guest#
  57 ##############################################################################
  58
  59 # While original submission covers 512- and 1024-bit exponentiation,
  60 # this module is limited to 512-bit version only (and as such
  61 # accelerates RSA1024 sign). This is because improvement for longer
  62 # keys is not high enough to justify the effort, highest measured
  63 # was ~5% on Westmere. [This is relative to OpenSSL 1.0.2, upcoming
  64 # for the moment of this writing!] Nor does this module implement
  65 # "monolithic" complete exponentiation jumbo-subroutine, but adheres
  66 # to more modular mixture of C and assembly. And it's optimized even
  67 # for processors other than Intel Core family (see table below for
  68 # improvement coefficients).
  69 #                                               <appro@openssl.org>
  70 #
  71 # RSA1024 sign/sec      this/original   |this/rsax(*)   this/fips(*)
  72 #                       ----------------+---------------------------
  73 # Opteron               +13%            |+5%            +20%
  74 # Bulldozer             -0%             |-1%            +10%
  75 # P4                    +11%            |+7%            +8%
  76 # Westmere              +5%             |+14%           +17%
  77 # Sandy Bridge          +2%             |+12%           +29%
  78 # Ivy Bridge            +1%             |+11%           +35%
  79 # Haswell(**)           -0%             |+12%           +39%
  80 # Atom                  +13%            |+11%           +4%
  81 # VIA Nano              +70%            |+9%            +25%
  82 #
  83 # (*)   rsax engine and fips numbers are presented for reference
  84 #       purposes;
  85 # (**)  MULX was attempted, but found to give only marginal improvement;
  86
  87 $flavour = shift;
  88 $output  = shift;
  89 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
  90
  91 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
  92
  93 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  94 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
  95 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
  96 die "can't locate x86_64-xlate.pl";
  97
  98 open OUT,"| \"$^X\" $xlate $flavour $output";
  99 *STDOUT=*OUT;
 100
 101 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
 102                 =~ /GNU assembler version ([2-9]\.[0-9]+)/) {
 103         $addx = ($1>=2.23);
 104 }
 105
 106 if (!$addx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
 107             `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
 108         $addx = ($1>=2.10);
 109 }
 110
 111 if (!$addx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
 112             `ml64 2>&1` =~ /Version ([0-9]+)\./) {
 113         $addx = ($1>=12);
 114 }
 115
 116 if (!$addx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|.*based on LLVM) ([3-9])\.([0-9]+)/) {
 117         my $ver = $2 + $3/100.0;        # 3.1->3.01, 3.10->3.10
 118         $addx = ($ver>=3.03);
 119 }
 120
 121 ($out, $inp, $mod) = ("%rdi", "%rsi", "%rbp");  # common internal API
 122 {
 123 my ($out,$inp,$mod,$n0,$times) = ("%rdi","%rsi","%rdx","%rcx","%r8d");
 124
 125 $code.=<<___;
 126 .text
 127
 128 .extern OPENSSL_ia32cap_P
 129
 130 .globl  rsaz_512_sqr
 131 .type   rsaz_512_sqr,\@function,5
 132 .align  32
 133 rsaz_512_sqr:                           # 25-29% faster than rsaz_512_mul
 134         push    %rbx
 135         push    %rbp
 136         push    %r12
 137         push    %r13
 138         push    %r14
 139         push    %r15
 140
 141         subq    \$128+24, %rsp
 142 .Lsqr_body:
 143         movq    $mod, %rbp              # common argument
 144         movq    ($inp), %rdx
 145         movq    8($inp), %rax
 146         movq    $n0, 128(%rsp)
 147 ___
 148 $code.=<<___ if ($addx);
 149         movl    \$0x80100,%r11d
 150         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
 151         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
 152         je      .Loop_sqrx
 153 ___
 154 $code.=<<___;
 155         jmp     .Loop_sqr
 156
 157 .align  32
 158 .Loop_sqr:
 159         movl    $times,128+8(%rsp)
 160 #first iteration
 161         movq    %rdx, %rbx
 162         mulq    %rdx
 163         movq    %rax, %r8
 164         movq    16($inp), %rax
 165         movq    %rdx, %r9
 166
 167         mulq    %rbx
 168         addq    %rax, %r9
 169         movq    24($inp), %rax
 170         movq    %rdx, %r10
 171         adcq    \$0, %r10
 172
 173         mulq    %rbx
 174         addq    %rax, %r10
 175         movq    32($inp), %rax
 176         movq    %rdx, %r11
 177         adcq    \$0, %r11
 178
 179         mulq    %rbx
 180         addq    %rax, %r11
 181         movq    40($inp), %rax
 182         movq    %rdx, %r12
 183         adcq    \$0, %r12
 184
 185         mulq    %rbx
 186         addq    %rax, %r12
 187         movq    48($inp), %rax
 188         movq    %rdx, %r13
 189         adcq    \$0, %r13
 190
 191         mulq    %rbx
 192         addq    %rax, %r13
 193         movq    56($inp), %rax
 194         movq    %rdx, %r14
 195         adcq    \$0, %r14
 196
 197         mulq    %rbx
 198         addq    %rax, %r14
 199         movq    %rbx, %rax
 200         movq    %rdx, %r15
 201         adcq    \$0, %r15
 202
 203         addq    %r8, %r8                #shlq   \$1, %r8
 204         movq    %r9, %rcx
 205         adcq    %r9, %r9                #shld   \$1, %r8, %r9
 206
 207         mulq    %rax
 208         movq    %rax, (%rsp)
 209         addq    %rdx, %r8
 210         adcq    \$0, %r9
 211
 212         movq    %r8, 8(%rsp)
 213         shrq    \$63, %rcx
 214
 215 #second iteration
 216         movq    8($inp), %r8
 217         movq    16($inp), %rax
 218         mulq    %r8
 219         addq    %rax, %r10
 220         movq    24($inp), %rax
 221         movq    %rdx, %rbx
 222         adcq    \$0, %rbx
 223
 224         mulq    %r8
 225         addq    %rax, %r11
 226         movq    32($inp), %rax
 227         adcq    \$0, %rdx
 228         addq    %rbx, %r11
 229         movq    %rdx, %rbx
 230         adcq    \$0, %rbx
 231
 232         mulq    %r8
 233         addq    %rax, %r12
 234         movq    40($inp), %rax
 235         adcq    \$0, %rdx
 236         addq    %rbx, %r12
 237         movq    %rdx, %rbx
 238         adcq    \$0, %rbx
 239
 240         mulq    %r8
 241         addq    %rax, %r13
 242         movq    48($inp), %rax
 243         adcq    \$0, %rdx
 244         addq    %rbx, %r13
 245         movq    %rdx, %rbx
 246         adcq    \$0, %rbx
 247
 248         mulq    %r8
 249         addq    %rax, %r14
 250         movq    56($inp), %rax
 251         adcq    \$0, %rdx
 252         addq    %rbx, %r14
 253         movq    %rdx, %rbx
 254         adcq    \$0, %rbx
 255
 256         mulq    %r8
 257         addq    %rax, %r15
 258         movq    %r8, %rax
 259         adcq    \$0, %rdx
 260         addq    %rbx, %r15
 261         movq    %rdx, %r8
 262         movq    %r10, %rdx
 263         adcq    \$0, %r8
 264
 265         add     %rdx, %rdx
 266         lea     (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
 267         movq    %r11, %rbx
 268         adcq    %r11, %r11              #shld   \$1, %r10, %r11
 269
 270         mulq    %rax
 271         addq    %rax, %r9
 272         adcq    %rdx, %r10
 273         adcq    \$0, %r11
 274
 275         movq    %r9, 16(%rsp)
 276         movq    %r10, 24(%rsp)
 277         shrq    \$63, %rbx
 278
 279 #third iteration
 280         movq    16($inp), %r9
 281         movq    24($inp), %rax
 282         mulq    %r9
 283         addq    %rax, %r12
 284         movq    32($inp), %rax
 285         movq    %rdx, %rcx
 286         adcq    \$0, %rcx
 287
 288         mulq    %r9
 289         addq    %rax, %r13
 290         movq    40($inp), %rax
 291         adcq    \$0, %rdx
 292         addq    %rcx, %r13
 293         movq    %rdx, %rcx
 294         adcq    \$0, %rcx
 295
 296         mulq    %r9
 297         addq    %rax, %r14
 298         movq    48($inp), %rax
 299         adcq    \$0, %rdx
 300         addq    %rcx, %r14
 301         movq    %rdx, %rcx
 302         adcq    \$0, %rcx
 303
 304         mulq    %r9
 305          movq   %r12, %r10
 306          lea    (%rbx,%r12,2), %r12     #shld   \$1, %rbx, %r12
 307         addq    %rax, %r15
 308         movq    56($inp), %rax
 309         adcq    \$0, %rdx
 310         addq    %rcx, %r15
 311         movq    %rdx, %rcx
 312         adcq    \$0, %rcx
 313
 314         mulq    %r9
 315          shrq   \$63, %r10
 316         addq    %rax, %r8
 317         movq    %r9, %rax
 318         adcq    \$0, %rdx
 319         addq    %rcx, %r8
 320         movq    %rdx, %r9
 321         adcq    \$0, %r9
 322
 323         movq    %r13, %rcx
 324         leaq    (%r10,%r13,2), %r13     #shld   \$1, %r12, %r13
 325
 326         mulq    %rax
 327         addq    %rax, %r11
 328         adcq    %rdx, %r12
 329         adcq    \$0, %r13
 330
 331         movq    %r11, 32(%rsp)
 332         movq    %r12, 40(%rsp)
 333         shrq    \$63, %rcx
 334
 335 #fourth iteration
 336         movq    24($inp), %r10
 337         movq    32($inp), %rax
 338         mulq    %r10
 339         addq    %rax, %r14
 340         movq    40($inp), %rax
 341         movq    %rdx, %rbx
 342         adcq    \$0, %rbx
 343
 344         mulq    %r10
 345         addq    %rax, %r15
 346         movq    48($inp), %rax
 347         adcq    \$0, %rdx
 348         addq    %rbx, %r15
 349         movq    %rdx, %rbx
 350         adcq    \$0, %rbx
 351
 352         mulq    %r10
 353          movq   %r14, %r12
 354          leaq   (%rcx,%r14,2), %r14     #shld   \$1, %rcx, %r14
 355         addq    %rax, %r8
 356         movq    56($inp), %rax
 357         adcq    \$0, %rdx
 358         addq    %rbx, %r8
 359         movq    %rdx, %rbx
 360         adcq    \$0, %rbx
 361
 362         mulq    %r10
 363          shrq   \$63, %r12
 364         addq    %rax, %r9
 365         movq    %r10, %rax
 366         adcq    \$0, %rdx
 367         addq    %rbx, %r9
 368         movq    %rdx, %r10
 369         adcq    \$0, %r10
 370
 371         movq    %r15, %rbx
 372         leaq    (%r12,%r15,2),%r15      #shld   \$1, %r14, %r15
 373
 374         mulq    %rax
 375         addq    %rax, %r13
 376         adcq    %rdx, %r14
 377         adcq    \$0, %r15
 378
 379         movq    %r13, 48(%rsp)
 380         movq    %r14, 56(%rsp)
 381         shrq    \$63, %rbx
 382
 383 #fifth iteration
 384         movq    32($inp), %r11
 385         movq    40($inp), %rax
 386         mulq    %r11
 387         addq    %rax, %r8
 388         movq    48($inp), %rax
 389         movq    %rdx, %rcx
 390         adcq    \$0, %rcx
 391
 392         mulq    %r11
 393         addq    %rax, %r9
 394         movq    56($inp), %rax
 395         adcq    \$0, %rdx
 396          movq   %r8, %r12
 397          leaq   (%rbx,%r8,2), %r8       #shld   \$1, %rbx, %r8
 398         addq    %rcx, %r9
 399         movq    %rdx, %rcx
 400         adcq    \$0, %rcx
 401
 402         mulq    %r11
 403          shrq   \$63, %r12
 404         addq    %rax, %r10
 405         movq    %r11, %rax
 406         adcq    \$0, %rdx
 407         addq    %rcx, %r10
 408         movq    %rdx, %r11
 409         adcq    \$0, %r11
 410
 411         movq    %r9, %rcx
 412         leaq    (%r12,%r9,2), %r9       #shld   \$1, %r8, %r9
 413
 414         mulq    %rax
 415         addq    %rax, %r15
 416         adcq    %rdx, %r8
 417         adcq    \$0, %r9
 418
 419         movq    %r15, 64(%rsp)
 420         movq    %r8, 72(%rsp)
 421         shrq    \$63, %rcx
 422
 423 #sixth iteration
 424         movq    40($inp), %r12
 425         movq    48($inp), %rax
 426         mulq    %r12
 427         addq    %rax, %r10
 428         movq    56($inp), %rax
 429         movq    %rdx, %rbx
 430         adcq    \$0, %rbx
 431
 432         mulq    %r12
 433         addq    %rax, %r11
 434         movq    %r12, %rax
 435          movq   %r10, %r15
 436          leaq   (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
 437         adcq    \$0, %rdx
 438          shrq   \$63, %r15
 439         addq    %rbx, %r11
 440         movq    %rdx, %r12
 441         adcq    \$0, %r12
 442
 443         movq    %r11, %rbx
 444         leaq    (%r15,%r11,2), %r11     #shld   \$1, %r10, %r11
 445
 446         mulq    %rax
 447         addq    %rax, %r9
 448         adcq    %rdx, %r10
 449         adcq    \$0, %r11
 450
 451         movq    %r9, 80(%rsp)
 452         movq    %r10, 88(%rsp)
 453
 454 #seventh iteration
 455         movq    48($inp), %r13
 456         movq    56($inp), %rax
 457         mulq    %r13
 458         addq    %rax, %r12
 459         movq    %r13, %rax
 460         movq    %rdx, %r13
 461         adcq    \$0, %r13
 462
 463         xorq    %r14, %r14
 464         shlq    \$1, %rbx
 465         adcq    %r12, %r12              #shld   \$1, %rbx, %r12
 466         adcq    %r13, %r13              #shld   \$1, %r12, %r13
 467         adcq    %r14, %r14              #shld   \$1, %r13, %r14
 468
 469         mulq    %rax
 470         addq    %rax, %r11
 471         adcq    %rdx, %r12
 472         adcq    \$0, %r13
 473
 474         movq    %r11, 96(%rsp)
 475         movq    %r12, 104(%rsp)
 476
 477 #eighth iteration
 478         movq    56($inp), %rax
 479         mulq    %rax
 480         addq    %rax, %r13
 481         adcq    \$0, %rdx
 482
 483         addq    %rdx, %r14
 484
 485         movq    %r13, 112(%rsp)
 486         movq    %r14, 120(%rsp)
 487
 488         movq    (%rsp), %r8
 489         movq    8(%rsp), %r9
 490         movq    16(%rsp), %r10
 491         movq    24(%rsp), %r11
 492         movq    32(%rsp), %r12
 493         movq    40(%rsp), %r13
 494         movq    48(%rsp), %r14
 495         movq    56(%rsp), %r15
 496
 497         call    __rsaz_512_reduce
 498
 499         addq    64(%rsp), %r8
 500         adcq    72(%rsp), %r9
 501         adcq    80(%rsp), %r10
 502         adcq    88(%rsp), %r11
 503         adcq    96(%rsp), %r12
 504         adcq    104(%rsp), %r13
 505         adcq    112(%rsp), %r14
 506         adcq    120(%rsp), %r15
 507         sbbq    %rcx, %rcx
 508
 509         call    __rsaz_512_subtract
 510
 511         movq    %r8, %rdx
 512         movq    %r9, %rax
 513         movl    128+8(%rsp), $times
 514         movq    $out, $inp
 515
 516         decl    $times
 517         jnz     .Loop_sqr
 518 ___
 519 if ($addx) {
 520 $code.=<<___;
 521         jmp     .Lsqr_tail
 522
 523 .align  32
 524 .Loop_sqrx:
 525         movl    $times,128+8(%rsp)
 526         movq    $out, %xmm0             # off-load
 527         movq    %rbp, %xmm1             # off-load
 528 #first iteration
 529         mulx    %rax, %r8, %r9
 530
 531         mulx    16($inp), %rcx, %r10
 532         xor     %rbp, %rbp              # cf=0, of=0
 533
 534         mulx    24($inp), %rax, %r11
 535         adcx    %rcx, %r9
 536
 537         mulx    32($inp), %rcx, %r12
 538         adcx    %rax, %r10
 539
 540         mulx    40($inp), %rax, %r13
 541         adcx    %rcx, %r11
 542
 543         .byte   0xc4,0x62,0xf3,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($inp), %rcx, %r14
 544         adcx    %rax, %r12
 545         adcx    %rcx, %r13
 546
 547         .byte   0xc4,0x62,0xfb,0xf6,0xbe,0x38,0x00,0x00,0x00    # mulx  56($inp), %rax, %r15
 548         adcx    %rax, %r14
 549         adcx    %rbp, %r15              # %rbp is 0
 550
 551         mov     %r9, %rcx
 552         shld    \$1, %r8, %r9
 553         shl     \$1, %r8
 554
 555         xor     %ebp, %ebp
 556         mulx    %rdx, %rax, %rdx
 557         adcx    %rdx, %r8
 558          mov    8($inp), %rdx
 559         adcx    %rbp, %r9
 560
 561         mov     %rax, (%rsp)
 562         mov     %r8, 8(%rsp)
 563
 564 #second iteration
 565         mulx    16($inp), %rax, %rbx
 566         adox    %rax, %r10
 567         adcx    %rbx, %r11
 568
 569         .byte   0xc4,0x62,0xc3,0xf6,0x86,0x18,0x00,0x00,0x00    # mulx  24($inp), $out, %r8
 570         adox    $out, %r11
 571         adcx    %r8, %r12
 572
 573         mulx    32($inp), %rax, %rbx
 574         adox    %rax, %r12
 575         adcx    %rbx, %r13
 576
 577         mulx    40($inp), $out, %r8
 578         adox    $out, %r13
 579         adcx    %r8, %r14
 580
 581         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rbx
 582         adox    %rax, %r14
 583         adcx    %rbx, %r15
 584
 585         .byte   0xc4,0x62,0xc3,0xf6,0x86,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r8
 586         adox    $out, %r15
 587         adcx    %rbp, %r8
 588         adox    %rbp, %r8
 589
 590         mov     %r11, %rbx
 591         shld    \$1, %r10, %r11
 592         shld    \$1, %rcx, %r10
 593
 594         xor     %ebp,%ebp
 595         mulx    %rdx, %rax, %rcx
 596          mov    16($inp), %rdx
 597         adcx    %rax, %r9
 598         adcx    %rcx, %r10
 599         adcx    %rbp, %r11
 600
 601         mov     %r9, 16(%rsp)
 602         .byte   0x4c,0x89,0x94,0x24,0x18,0x00,0x00,0x00         # mov   %r10, 24(%rsp)
 603
 604 #third iteration
 605         .byte   0xc4,0x62,0xc3,0xf6,0x8e,0x18,0x00,0x00,0x00    # mulx  24($inp), $out, %r9
 606         adox    $out, %r12
 607         adcx    %r9, %r13
 608
 609         mulx    32($inp), %rax, %rcx
 610         adox    %rax, %r13
 611         adcx    %rcx, %r14
 612
 613         mulx    40($inp), $out, %r9
 614         adox    $out, %r14
 615         adcx    %r9, %r15
 616
 617         .byte   0xc4,0xe2,0xfb,0xf6,0x8e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rcx
 618         adox    %rax, %r15
 619         adcx    %rcx, %r8
 620
 621         .byte   0xc4,0x62,0xc3,0xf6,0x8e,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r9
 622         adox    $out, %r8
 623         adcx    %rbp, %r9
 624         adox    %rbp, %r9
 625
 626         mov     %r13, %rcx
 627         shld    \$1, %r12, %r13
 628         shld    \$1, %rbx, %r12
 629
 630         xor     %ebp, %ebp
 631         mulx    %rdx, %rax, %rdx
 632         adcx    %rax, %r11
 633         adcx    %rdx, %r12
 634          mov    24($inp), %rdx
 635         adcx    %rbp, %r13
 636
 637         mov     %r11, 32(%rsp)
 638         .byte   0x4c,0x89,0xa4,0x24,0x28,0x00,0x00,0x00         # mov   %r12, 40(%rsp)
 639
 640 #fourth iteration
 641         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x20,0x00,0x00,0x00    # mulx  32($inp), %rax, %rbx
 642         adox    %rax, %r14
 643         adcx    %rbx, %r15
 644
 645         mulx    40($inp), $out, %r10
 646         adox    $out, %r15
 647         adcx    %r10, %r8
 648
 649         mulx    48($inp), %rax, %rbx
 650         adox    %rax, %r8
 651         adcx    %rbx, %r9
 652
 653         mulx    56($inp), $out, %r10
 654         adox    $out, %r9
 655         adcx    %rbp, %r10
 656         adox    %rbp, %r10
 657
 658         .byte   0x66
 659         mov     %r15, %rbx
 660         shld    \$1, %r14, %r15
 661         shld    \$1, %rcx, %r14
 662
 663         xor     %ebp, %ebp
 664         mulx    %rdx, %rax, %rdx
 665         adcx    %rax, %r13
 666         adcx    %rdx, %r14
 667          mov    32($inp), %rdx
 668         adcx    %rbp, %r15
 669
 670         mov     %r13, 48(%rsp)
 671         mov     %r14, 56(%rsp)
 672
 673 #fifth iteration
 674         .byte   0xc4,0x62,0xc3,0xf6,0x9e,0x28,0x00,0x00,0x00    # mulx  40($inp), $out, %r11
 675         adox    $out, %r8
 676         adcx    %r11, %r9
 677
 678         mulx    48($inp), %rax, %rcx
 679         adox    %rax, %r9
 680         adcx    %rcx, %r10
 681
 682         mulx    56($inp), $out, %r11
 683         adox    $out, %r10
 684         adcx    %rbp, %r11
 685         adox    %rbp, %r11
 686
 687         mov     %r9, %rcx
 688         shld    \$1, %r8, %r9
 689         shld    \$1, %rbx, %r8
 690
 691         xor     %ebp, %ebp
 692         mulx    %rdx, %rax, %rdx
 693         adcx    %rax, %r15
 694         adcx    %rdx, %r8
 695          mov    40($inp), %rdx
 696         adcx    %rbp, %r9
 697
 698         mov     %r15, 64(%rsp)
 699         mov     %r8, 72(%rsp)
 700
 701 #sixth iteration
 702         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rbx
 703         adox    %rax, %r10
 704         adcx    %rbx, %r11
 705
 706         .byte   0xc4,0x62,0xc3,0xf6,0xa6,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r12
 707         adox    $out, %r11
 708         adcx    %rbp, %r12
 709         adox    %rbp, %r12
 710
 711         mov     %r11, %rbx
 712         shld    \$1, %r10, %r11
 713         shld    \$1, %rcx, %r10
 714
 715         xor     %ebp, %ebp
 716         mulx    %rdx, %rax, %rdx
 717         adcx    %rax, %r9
 718         adcx    %rdx, %r10
 719          mov    48($inp), %rdx
 720         adcx    %rbp, %r11
 721
 722         mov     %r9, 80(%rsp)
 723         mov     %r10, 88(%rsp)
 724
 725 #seventh iteration
 726         .byte   0xc4,0x62,0xfb,0xf6,0xae,0x38,0x00,0x00,0x00    # mulx  56($inp), %rax, %r13
 727         adox    %rax, %r12
 728         adox    %rbp, %r13
 729
 730         xor     %r14, %r14
 731         shld    \$1, %r13, %r14
 732         shld    \$1, %r12, %r13
 733         shld    \$1, %rbx, %r12
 734
 735         xor     %ebp, %ebp
 736         mulx    %rdx, %rax, %rdx
 737         adcx    %rax, %r11
 738         adcx    %rdx, %r12
 739          mov    56($inp), %rdx
 740         adcx    %rbp, %r13
 741
 742         .byte   0x4c,0x89,0x9c,0x24,0x60,0x00,0x00,0x00         # mov   %r11, 96(%rsp)
 743         .byte   0x4c,0x89,0xa4,0x24,0x68,0x00,0x00,0x00         # mov   %r12, 104(%rsp)
 744
 745 #eighth iteration
 746         mulx    %rdx, %rax, %rdx
 747         adox    %rax, %r13
 748         adox    %rbp, %rdx
 749
 750         .byte   0x66
 751         add     %rdx, %r14
 752
 753         movq    %r13, 112(%rsp)
 754         movq    %r14, 120(%rsp)
 755         movq    %xmm0, $out
 756         movq    %xmm1, %rbp
 757
 758         movq    128(%rsp), %rdx         # pull $n0
 759         movq    (%rsp), %r8
 760         movq    8(%rsp), %r9
 761         movq    16(%rsp), %r10
 762         movq    24(%rsp), %r11
 763         movq    32(%rsp), %r12
 764         movq    40(%rsp), %r13
 765         movq    48(%rsp), %r14
 766         movq    56(%rsp), %r15
 767
 768         call    __rsaz_512_reducex
 769
 770         addq    64(%rsp), %r8
 771         adcq    72(%rsp), %r9
 772         adcq    80(%rsp), %r10
 773         adcq    88(%rsp), %r11
 774         adcq    96(%rsp), %r12
 775         adcq    104(%rsp), %r13
 776         adcq    112(%rsp), %r14
 777         adcq    120(%rsp), %r15
 778         sbbq    %rcx, %rcx
 779
 780         call    __rsaz_512_subtract
 781
 782         movq    %r8, %rdx
 783         movq    %r9, %rax
 784         movl    128+8(%rsp), $times
 785         movq    $out, $inp
 786
 787         decl    $times
 788         jnz     .Loop_sqrx
 789
 790 .Lsqr_tail:
 791 ___
 792 }
 793 $code.=<<___;
 794
 795         leaq    128+24+48(%rsp), %rax
 796         movq    -48(%rax), %r15
 797         movq    -40(%rax), %r14
 798         movq    -32(%rax), %r13
 799         movq    -24(%rax), %r12
 800         movq    -16(%rax), %rbp
 801         movq    -8(%rax), %rbx
 802         leaq    (%rax), %rsp
 803 .Lsqr_epilogue:
 804         ret
 805 .size   rsaz_512_sqr,.-rsaz_512_sqr
 806 ___
 807 }
 808 {
 809 my ($out,$ap,$bp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx","%r8");
 810 $code.=<<___;
 811 .globl  rsaz_512_mul
 812 .type   rsaz_512_mul,\@function,5
 813 .align  32
 814 rsaz_512_mul:
 815         push    %rbx
 816         push    %rbp
 817         push    %r12
 818         push    %r13
 819         push    %r14
 820         push    %r15
 821
 822         subq    \$128+24, %rsp
 823 .Lmul_body:
 824         movq    $out, %xmm0             # off-load arguments
 825         movq    $mod, %xmm1
 826         movq    $n0, 128(%rsp)
 827 ___
 828 $code.=<<___ if ($addx);
 829         movl    \$0x80100,%r11d
 830         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
 831         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
 832         je      .Lmulx
 833 ___
 834 $code.=<<___;
 835         movq    ($bp), %rbx             # pass b[0]
 836         movq    $bp, %rbp               # pass argument
 837         call    __rsaz_512_mul
 838
 839         movq    %xmm0, $out
 840         movq    %xmm1, %rbp
 841
 842         movq    (%rsp), %r8
 843         movq    8(%rsp), %r9
 844         movq    16(%rsp), %r10
 845         movq    24(%rsp), %r11
 846         movq    32(%rsp), %r12
 847         movq    40(%rsp), %r13
 848         movq    48(%rsp), %r14
 849         movq    56(%rsp), %r15
 850
 851         call    __rsaz_512_reduce
 852 ___
 853 $code.=<<___ if ($addx);
 854         jmp     .Lmul_tail
 855
 856 .align  32
 857 .Lmulx:
 858         movq    $bp, %rbp               # pass argument
 859         movq    ($bp), %rdx             # pass b[0]
 860         call    __rsaz_512_mulx
 861
 862         movq    %xmm0, $out
 863         movq    %xmm1, %rbp
 864
 865         movq    128(%rsp), %rdx         # pull $n0
 866         movq    (%rsp), %r8
 867         movq    8(%rsp), %r9
 868         movq    16(%rsp), %r10
 869         movq    24(%rsp), %r11
 870         movq    32(%rsp), %r12
 871         movq    40(%rsp), %r13
 872         movq    48(%rsp), %r14
 873         movq    56(%rsp), %r15
 874
 875         call    __rsaz_512_reducex
 876 .Lmul_tail:
 877 ___
 878 $code.=<<___;
 879         addq    64(%rsp), %r8
 880         adcq    72(%rsp), %r9
 881         adcq    80(%rsp), %r10
 882         adcq    88(%rsp), %r11
 883         adcq    96(%rsp), %r12
 884         adcq    104(%rsp), %r13
 885         adcq    112(%rsp), %r14
 886         adcq    120(%rsp), %r15
 887         sbbq    %rcx, %rcx
 888
 889         call    __rsaz_512_subtract
 890
 891         leaq    128+24+48(%rsp), %rax
 892         movq    -48(%rax), %r15
 893         movq    -40(%rax), %r14
 894         movq    -32(%rax), %r13
 895         movq    -24(%rax), %r12
 896         movq    -16(%rax), %rbp
 897         movq    -8(%rax), %rbx
 898         leaq    (%rax), %rsp
 899 .Lmul_epilogue:
 900         ret
 901 .size   rsaz_512_mul,.-rsaz_512_mul
 902 ___
 903 }
 904 {
 905 my ($out,$ap,$bp,$mod,$n0,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
 906 $code.=<<___;
 907 .globl  rsaz_512_mul_gather4
 908 .type   rsaz_512_mul_gather4,\@function,6
 909 .align  32
 910 rsaz_512_mul_gather4:
 911         push    %rbx
 912         push    %rbp
 913         push    %r12
 914         push    %r13
 915         push    %r14
 916         push    %r15
 917
 918         subq    \$`128+24+($win64?0xb0:0)`, %rsp
 919 ___
 920 $code.=<<___    if ($win64);
 921         movaps  %xmm6,0xa0(%rsp)
 922         movaps  %xmm7,0xb0(%rsp)
 923         movaps  %xmm8,0xc0(%rsp)
 924         movaps  %xmm9,0xd0(%rsp)
 925         movaps  %xmm10,0xe0(%rsp)
 926         movaps  %xmm11,0xf0(%rsp)
 927         movaps  %xmm12,0x100(%rsp)
 928         movaps  %xmm13,0x110(%rsp)
 929         movaps  %xmm14,0x120(%rsp)
 930         movaps  %xmm15,0x130(%rsp)
 931 ___
 932 $code.=<<___;
 933 .Lmul_gather4_body:
 934         movd    $pwr,%xmm8
 935         movdqa  .Linc+16(%rip),%xmm1    # 00000002000000020000000200000002
 936         movdqa  .Linc(%rip),%xmm0       # 00000001000000010000000000000000
 937
 938         pshufd  \$0,%xmm8,%xmm8         # broadcast $power
 939         movdqa  %xmm1,%xmm7
 940         movdqa  %xmm1,%xmm2
 941 ___
 942 ########################################################################
 943 # calculate mask by comparing 0..15 to $power
 944 #
 945 for($i=0;$i<4;$i++) {
 946 $code.=<<___;
 947         paddd   %xmm`$i`,%xmm`$i+1`
 948         pcmpeqd %xmm8,%xmm`$i`
 949         movdqa  %xmm7,%xmm`$i+3`
 950 ___
 951 }
 952 for(;$i<7;$i++) {
 953 $code.=<<___;
 954         paddd   %xmm`$i`,%xmm`$i+1`
 955         pcmpeqd %xmm8,%xmm`$i`
 956 ___
 957 }
 958 $code.=<<___;
 959         pcmpeqd %xmm8,%xmm7
 960
 961         movdqa  16*0($bp),%xmm8
 962         movdqa  16*1($bp),%xmm9
 963         movdqa  16*2($bp),%xmm10
 964         movdqa  16*3($bp),%xmm11
 965         pand    %xmm0,%xmm8
 966         movdqa  16*4($bp),%xmm12
 967         pand    %xmm1,%xmm9
 968         movdqa  16*5($bp),%xmm13
 969         pand    %xmm2,%xmm10
 970         movdqa  16*6($bp),%xmm14
 971         pand    %xmm3,%xmm11
 972         movdqa  16*7($bp),%xmm15
 973         leaq    128($bp), %rbp
 974         pand    %xmm4,%xmm12
 975         pand    %xmm5,%xmm13
 976         pand    %xmm6,%xmm14
 977         pand    %xmm7,%xmm15
 978         por     %xmm10,%xmm8
 979         por     %xmm11,%xmm9
 980         por     %xmm12,%xmm8
 981         por     %xmm13,%xmm9
 982         por     %xmm14,%xmm8
 983         por     %xmm15,%xmm9
 984
 985         por     %xmm9,%xmm8
 986         pshufd  \$0x4e,%xmm8,%xmm9
 987         por     %xmm9,%xmm8
 988 ___
 989 $code.=<<___ if ($addx);
 990         movl    \$0x80100,%r11d
 991         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
 992         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
 993         je      .Lmulx_gather
 994 ___
 995 $code.=<<___;
 996         movq    %xmm8,%rbx
 997
 998         movq    $n0, 128(%rsp)          # off-load arguments
 999         movq    $out, 128+8(%rsp)
1000         movq    $mod, 128+16(%rsp)
1001
1002         movq    ($ap), %rax
1003          movq   8($ap), %rcx
1004         mulq    %rbx                    # 0 iteration
1005         movq    %rax, (%rsp)
1006         movq    %rcx, %rax
1007         movq    %rdx, %r8
1008
1009         mulq    %rbx
1010         addq    %rax, %r8
1011         movq    16($ap), %rax
1012         movq    %rdx, %r9
1013         adcq    \$0, %r9
1014
1015         mulq    %rbx
1016         addq    %rax, %r9
1017         movq    24($ap), %rax
1018         movq    %rdx, %r10
1019         adcq    \$0, %r10
1020
1021         mulq    %rbx
1022         addq    %rax, %r10
1023         movq    32($ap), %rax
1024         movq    %rdx, %r11
1025         adcq    \$0, %r11
1026
1027         mulq    %rbx
1028         addq    %rax, %r11
1029         movq    40($ap), %rax
1030         movq    %rdx, %r12
1031         adcq    \$0, %r12
1032
1033         mulq    %rbx
1034         addq    %rax, %r12
1035         movq    48($ap), %rax
1036         movq    %rdx, %r13
1037         adcq    \$0, %r13
1038
1039         mulq    %rbx
1040         addq    %rax, %r13
1041         movq    56($ap), %rax
1042         movq    %rdx, %r14
1043         adcq    \$0, %r14
1044
1045         mulq    %rbx
1046         addq    %rax, %r14
1047          movq   ($ap), %rax
1048         movq    %rdx, %r15
1049         adcq    \$0, %r15
1050
1051         leaq    8(%rsp), %rdi
1052         movl    \$7, %ecx
1053         jmp     .Loop_mul_gather
1054
1055 .align  32
1056 .Loop_mul_gather:
1057         movdqa  16*0(%rbp),%xmm8
1058         movdqa  16*1(%rbp),%xmm9
1059         movdqa  16*2(%rbp),%xmm10
1060         movdqa  16*3(%rbp),%xmm11
1061         pand    %xmm0,%xmm8
1062         movdqa  16*4(%rbp),%xmm12
1063         pand    %xmm1,%xmm9
1064         movdqa  16*5(%rbp),%xmm13
1065         pand    %xmm2,%xmm10
1066         movdqa  16*6(%rbp),%xmm14
1067         pand    %xmm3,%xmm11
1068         movdqa  16*7(%rbp),%xmm15
1069         leaq    128(%rbp), %rbp
1070         pand    %xmm4,%xmm12
1071         pand    %xmm5,%xmm13
1072         pand    %xmm6,%xmm14
1073         pand    %xmm7,%xmm15
1074         por     %xmm10,%xmm8
1075         por     %xmm11,%xmm9
1076         por     %xmm12,%xmm8
1077         por     %xmm13,%xmm9
1078         por     %xmm14,%xmm8
1079         por     %xmm15,%xmm9
1080
1081         por     %xmm9,%xmm8
1082         pshufd  \$0x4e,%xmm8,%xmm9
1083         por     %xmm9,%xmm8
1084         movq    %xmm8,%rbx
1085
1086         mulq    %rbx
1087         addq    %rax, %r8
1088         movq    8($ap), %rax
1089         movq    %r8, (%rdi)
1090         movq    %rdx, %r8
1091         adcq    \$0, %r8
1092
1093         mulq    %rbx
1094         addq    %rax, %r9
1095         movq    16($ap), %rax
1096         adcq    \$0, %rdx
1097         addq    %r9, %r8
1098         movq    %rdx, %r9
1099         adcq    \$0, %r9
1100
1101         mulq    %rbx
1102         addq    %rax, %r10
1103         movq    24($ap), %rax
1104         adcq    \$0, %rdx
1105         addq    %r10, %r9
1106         movq    %rdx, %r10
1107         adcq    \$0, %r10
1108
1109         mulq    %rbx
1110         addq    %rax, %r11
1111         movq    32($ap), %rax
1112         adcq    \$0, %rdx
1113         addq    %r11, %r10
1114         movq    %rdx, %r11
1115         adcq    \$0, %r11
1116
1117         mulq    %rbx
1118         addq    %rax, %r12
1119         movq    40($ap), %rax
1120         adcq    \$0, %rdx
1121         addq    %r12, %r11
1122         movq    %rdx, %r12
1123         adcq    \$0, %r12
1124
1125         mulq    %rbx
1126         addq    %rax, %r13
1127         movq    48($ap), %rax
1128         adcq    \$0, %rdx
1129         addq    %r13, %r12
1130         movq    %rdx, %r13
1131         adcq    \$0, %r13
1132
1133         mulq    %rbx
1134         addq    %rax, %r14
1135         movq    56($ap), %rax
1136         adcq    \$0, %rdx
1137         addq    %r14, %r13
1138         movq    %rdx, %r14
1139         adcq    \$0, %r14
1140
1141         mulq    %rbx
1142         addq    %rax, %r15
1143          movq   ($ap), %rax
1144         adcq    \$0, %rdx
1145         addq    %r15, %r14
1146         movq    %rdx, %r15
1147         adcq    \$0, %r15
1148
1149         leaq    8(%rdi), %rdi
1150
1151         decl    %ecx
1152         jnz     .Loop_mul_gather
1153
1154         movq    %r8, (%rdi)
1155         movq    %r9, 8(%rdi)
1156         movq    %r10, 16(%rdi)
1157         movq    %r11, 24(%rdi)
1158         movq    %r12, 32(%rdi)
1159         movq    %r13, 40(%rdi)
1160         movq    %r14, 48(%rdi)
1161         movq    %r15, 56(%rdi)
1162
1163         movq    128+8(%rsp), $out
1164         movq    128+16(%rsp), %rbp
1165
1166         movq    (%rsp), %r8
1167         movq    8(%rsp), %r9
1168         movq    16(%rsp), %r10
1169         movq    24(%rsp), %r11
1170         movq    32(%rsp), %r12
1171         movq    40(%rsp), %r13
1172         movq    48(%rsp), %r14
1173         movq    56(%rsp), %r15
1174
1175         call    __rsaz_512_reduce
1176 ___
1177 $code.=<<___ if ($addx);
1178         jmp     .Lmul_gather_tail
1179
1180 .align  32
1181 .Lmulx_gather:
1182         movq    %xmm8,%rdx
1183
1184         mov     $n0, 128(%rsp)          # off-load arguments
1185         mov     $out, 128+8(%rsp)
1186         mov     $mod, 128+16(%rsp)
1187
1188         mulx    ($ap), %rbx, %r8        # 0 iteration
1189         mov     %rbx, (%rsp)
1190         xor     %edi, %edi              # cf=0, of=0
1191
1192         mulx    8($ap), %rax, %r9
1193
1194         mulx    16($ap), %rbx, %r10
1195         adcx    %rax, %r8
1196
1197         mulx    24($ap), %rax, %r11
1198         adcx    %rbx, %r9
1199
1200         mulx    32($ap), %rbx, %r12
1201         adcx    %rax, %r10
1202
1203         mulx    40($ap), %rax, %r13
1204         adcx    %rbx, %r11
1205
1206         mulx    48($ap), %rbx, %r14
1207         adcx    %rax, %r12
1208
1209         mulx    56($ap), %rax, %r15
1210         adcx    %rbx, %r13
1211         adcx    %rax, %r14
1212         .byte   0x67
1213         mov     %r8, %rbx
1214         adcx    %rdi, %r15              # %rdi is 0
1215
1216         mov     \$-7, %rcx
1217         jmp     .Loop_mulx_gather
1218
1219 .align  32
1220 .Loop_mulx_gather:
1221         movdqa  16*0(%rbp),%xmm8
1222         movdqa  16*1(%rbp),%xmm9
1223         movdqa  16*2(%rbp),%xmm10
1224         movdqa  16*3(%rbp),%xmm11
1225         pand    %xmm0,%xmm8
1226         movdqa  16*4(%rbp),%xmm12
1227         pand    %xmm1,%xmm9
1228         movdqa  16*5(%rbp),%xmm13
1229         pand    %xmm2,%xmm10
1230         movdqa  16*6(%rbp),%xmm14
1231         pand    %xmm3,%xmm11
1232         movdqa  16*7(%rbp),%xmm15
1233         leaq    128(%rbp), %rbp
1234         pand    %xmm4,%xmm12
1235         pand    %xmm5,%xmm13
1236         pand    %xmm6,%xmm14
1237         pand    %xmm7,%xmm15
1238         por     %xmm10,%xmm8
1239         por     %xmm11,%xmm9
1240         por     %xmm12,%xmm8
1241         por     %xmm13,%xmm9
1242         por     %xmm14,%xmm8
1243         por     %xmm15,%xmm9
1244
1245         por     %xmm9,%xmm8
1246         pshufd  \$0x4e,%xmm8,%xmm9
1247         por     %xmm9,%xmm8
1248         movq    %xmm8,%rdx
1249
1250         .byte   0xc4,0x62,0xfb,0xf6,0x86,0x00,0x00,0x00,0x00    # mulx  ($ap), %rax, %r8
1251         adcx    %rax, %rbx
1252         adox    %r9, %r8
1253
1254         mulx    8($ap), %rax, %r9
1255         adcx    %rax, %r8
1256         adox    %r10, %r9
1257
1258         mulx    16($ap), %rax, %r10
1259         adcx    %rax, %r9
1260         adox    %r11, %r10
1261
1262         .byte   0xc4,0x62,0xfb,0xf6,0x9e,0x18,0x00,0x00,0x00    # mulx  24($ap), %rax, %r11
1263         adcx    %rax, %r10
1264         adox    %r12, %r11
1265
1266         mulx    32($ap), %rax, %r12
1267         adcx    %rax, %r11
1268         adox    %r13, %r12
1269
1270         mulx    40($ap), %rax, %r13
1271         adcx    %rax, %r12
1272         adox    %r14, %r13
1273
1274         .byte   0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($ap), %rax, %r14
1275         adcx    %rax, %r13
1276         .byte   0x67
1277         adox    %r15, %r14
1278
1279         mulx    56($ap), %rax, %r15
1280          mov    %rbx, 64(%rsp,%rcx,8)
1281         adcx    %rax, %r14
1282         adox    %rdi, %r15
1283         mov     %r8, %rbx
1284         adcx    %rdi, %r15              # cf=0
1285
1286         inc     %rcx                    # of=0
1287         jnz     .Loop_mulx_gather
1288
1289         mov     %r8, 64(%rsp)
1290         mov     %r9, 64+8(%rsp)
1291         mov     %r10, 64+16(%rsp)
1292         mov     %r11, 64+24(%rsp)
1293         mov     %r12, 64+32(%rsp)
1294         mov     %r13, 64+40(%rsp)
1295         mov     %r14, 64+48(%rsp)
1296         mov     %r15, 64+56(%rsp)
1297
1298         mov     128(%rsp), %rdx         # pull arguments
1299         mov     128+8(%rsp), $out
1300         mov     128+16(%rsp), %rbp
1301
1302         mov     (%rsp), %r8
1303         mov     8(%rsp), %r9
1304         mov     16(%rsp), %r10
1305         mov     24(%rsp), %r11
1306         mov     32(%rsp), %r12
1307         mov     40(%rsp), %r13
1308         mov     48(%rsp), %r14
1309         mov     56(%rsp), %r15
1310
1311         call    __rsaz_512_reducex
1312
1313 .Lmul_gather_tail:
1314 ___
1315 $code.=<<___;
1316         addq    64(%rsp), %r8
1317         adcq    72(%rsp), %r9
1318         adcq    80(%rsp), %r10
1319         adcq    88(%rsp), %r11
1320         adcq    96(%rsp), %r12
1321         adcq    104(%rsp), %r13
1322         adcq    112(%rsp), %r14
1323         adcq    120(%rsp), %r15
1324         sbbq    %rcx, %rcx
1325
1326         call    __rsaz_512_subtract
1327
1328         leaq    128+24+48(%rsp), %rax
1329 ___
1330 $code.=<<___    if ($win64);
1331         movaps  0xa0-0xc8(%rax),%xmm6
1332         movaps  0xb0-0xc8(%rax),%xmm7
1333         movaps  0xc0-0xc8(%rax),%xmm8
1334         movaps  0xd0-0xc8(%rax),%xmm9
1335         movaps  0xe0-0xc8(%rax),%xmm10
1336         movaps  0xf0-0xc8(%rax),%xmm11
1337         movaps  0x100-0xc8(%rax),%xmm12
1338         movaps  0x110-0xc8(%rax),%xmm13
1339         movaps  0x120-0xc8(%rax),%xmm14
1340         movaps  0x130-0xc8(%rax),%xmm15
1341         lea     0xb0(%rax),%rax
1342 ___
1343 $code.=<<___;
1344         movq    -48(%rax), %r15
1345         movq    -40(%rax), %r14
1346         movq    -32(%rax), %r13
1347         movq    -24(%rax), %r12
1348         movq    -16(%rax), %rbp
1349         movq    -8(%rax), %rbx
1350         leaq    (%rax), %rsp
1351 .Lmul_gather4_epilogue:
1352         ret
1353 .size   rsaz_512_mul_gather4,.-rsaz_512_mul_gather4
1354 ___
1355 }
1356 {
1357 my ($out,$ap,$mod,$n0,$tbl,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
1358 $code.=<<___;
1359 .globl  rsaz_512_mul_scatter4
1360 .type   rsaz_512_mul_scatter4,\@function,6
1361 .align  32
1362 rsaz_512_mul_scatter4:
1363         push    %rbx
1364         push    %rbp
1365         push    %r12
1366         push    %r13
1367         push    %r14
1368         push    %r15
1369
1370         mov     $pwr, $pwr
1371         subq    \$128+24, %rsp
1372 .Lmul_scatter4_body:
1373         leaq    ($tbl,$pwr,8), $tbl
1374         movq    $out, %xmm0             # off-load arguments
1375         movq    $mod, %xmm1
1376         movq    $tbl, %xmm2
1377         movq    $n0, 128(%rsp)
1378
1379         movq    $out, %rbp
1380 ___
1381 $code.=<<___ if ($addx);
1382         movl    \$0x80100,%r11d
1383         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
1384         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
1385         je      .Lmulx_scatter
1386 ___
1387 $code.=<<___;
1388         movq    ($out),%rbx             # pass b[0]
1389         call    __rsaz_512_mul
1390
1391         movq    %xmm0, $out
1392         movq    %xmm1, %rbp
1393
1394         movq    (%rsp), %r8
1395         movq    8(%rsp), %r9
1396         movq    16(%rsp), %r10
1397         movq    24(%rsp), %r11
1398         movq    32(%rsp), %r12
1399         movq    40(%rsp), %r13
1400         movq    48(%rsp), %r14
1401         movq    56(%rsp), %r15
1402
1403         call    __rsaz_512_reduce
1404 ___
1405 $code.=<<___ if ($addx);
1406         jmp     .Lmul_scatter_tail
1407
1408 .align  32
1409 .Lmulx_scatter:
1410         movq    ($out), %rdx            # pass b[0]
1411         call    __rsaz_512_mulx
1412
1413         movq    %xmm0, $out
1414         movq    %xmm1, %rbp
1415
1416         movq    128(%rsp), %rdx         # pull $n0
1417         movq    (%rsp), %r8
1418         movq    8(%rsp), %r9
1419         movq    16(%rsp), %r10
1420         movq    24(%rsp), %r11
1421         movq    32(%rsp), %r12
1422         movq    40(%rsp), %r13
1423         movq    48(%rsp), %r14
1424         movq    56(%rsp), %r15
1425
1426         call    __rsaz_512_reducex
1427
1428 .Lmul_scatter_tail:
1429 ___
1430 $code.=<<___;
1431         addq    64(%rsp), %r8
1432         adcq    72(%rsp), %r9
1433         adcq    80(%rsp), %r10
1434         adcq    88(%rsp), %r11
1435         adcq    96(%rsp), %r12
1436         adcq    104(%rsp), %r13
1437         adcq    112(%rsp), %r14
1438         adcq    120(%rsp), %r15
1439         movq    %xmm2, $inp
1440         sbbq    %rcx, %rcx
1441
1442         call    __rsaz_512_subtract
1443
1444         movq    %r8, 128*0($inp)        # scatter
1445         movq    %r9, 128*1($inp)
1446         movq    %r10, 128*2($inp)
1447         movq    %r11, 128*3($inp)
1448         movq    %r12, 128*4($inp)
1449         movq    %r13, 128*5($inp)
1450         movq    %r14, 128*6($inp)
1451         movq    %r15, 128*7($inp)
1452
1453         leaq    128+24+48(%rsp), %rax
1454         movq    -48(%rax), %r15
1455         movq    -40(%rax), %r14
1456         movq    -32(%rax), %r13
1457         movq    -24(%rax), %r12
1458         movq    -16(%rax), %rbp
1459         movq    -8(%rax), %rbx
1460         leaq    (%rax), %rsp
1461 .Lmul_scatter4_epilogue:
1462         ret
1463 .size   rsaz_512_mul_scatter4,.-rsaz_512_mul_scatter4
1464 ___
1465 }
1466 {
1467 my ($out,$inp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx");
1468 $code.=<<___;
1469 .globl  rsaz_512_mul_by_one
1470 .type   rsaz_512_mul_by_one,\@function,4
1471 .align  32
1472 rsaz_512_mul_by_one:
1473         push    %rbx
1474         push    %rbp
1475         push    %r12
1476         push    %r13
1477         push    %r14
1478         push    %r15
1479
1480         subq    \$128+24, %rsp
1481 .Lmul_by_one_body:
1482 ___
1483 $code.=<<___ if ($addx);
1484         movl    OPENSSL_ia32cap_P+8(%rip),%eax
1485 ___
1486 $code.=<<___;
1487         movq    $mod, %rbp      # reassign argument
1488         movq    $n0, 128(%rsp)
1489
1490         movq    ($inp), %r8
1491         pxor    %xmm0, %xmm0
1492         movq    8($inp), %r9
1493         movq    16($inp), %r10
1494         movq    24($inp), %r11
1495         movq    32($inp), %r12
1496         movq    40($inp), %r13
1497         movq    48($inp), %r14
1498         movq    56($inp), %r15
1499
1500         movdqa  %xmm0, (%rsp)
1501         movdqa  %xmm0, 16(%rsp)
1502         movdqa  %xmm0, 32(%rsp)
1503         movdqa  %xmm0, 48(%rsp)
1504         movdqa  %xmm0, 64(%rsp)
1505         movdqa  %xmm0, 80(%rsp)
1506         movdqa  %xmm0, 96(%rsp)
1507 ___
1508 $code.=<<___ if ($addx);
1509         andl    \$0x80100,%eax
1510         cmpl    \$0x80100,%eax          # check for MULX and ADO/CX
1511         je      .Lby_one_callx
1512 ___
1513 $code.=<<___;
1514         call    __rsaz_512_reduce
1515 ___
1516 $code.=<<___ if ($addx);
1517         jmp     .Lby_one_tail
1518 .align  32
1519 .Lby_one_callx:
1520         movq    128(%rsp), %rdx         # pull $n0
1521         call    __rsaz_512_reducex
1522 .Lby_one_tail:
1523 ___
1524 $code.=<<___;
1525         movq    %r8, ($out)
1526         movq    %r9, 8($out)
1527         movq    %r10, 16($out)
1528         movq    %r11, 24($out)
1529         movq    %r12, 32($out)
1530         movq    %r13, 40($out)
1531         movq    %r14, 48($out)
1532         movq    %r15, 56($out)
1533
1534         leaq    128+24+48(%rsp), %rax
1535         movq    -48(%rax), %r15
1536         movq    -40(%rax), %r14
1537         movq    -32(%rax), %r13
1538         movq    -24(%rax), %r12
1539         movq    -16(%rax), %rbp
1540         movq    -8(%rax), %rbx
1541         leaq    (%rax), %rsp
1542 .Lmul_by_one_epilogue:
1543         ret
1544 .size   rsaz_512_mul_by_one,.-rsaz_512_mul_by_one
1545 ___
1546 }
1547 {       # __rsaz_512_reduce
1548         #
1549         # input:        %r8-%r15, %rbp - mod, 128(%rsp) - n0
1550         # output:       %r8-%r15
1551         # clobbers:     everything except %rbp and %rdi
1552 $code.=<<___;
1553 .type   __rsaz_512_reduce,\@abi-omnipotent
1554 .align  32
1555 __rsaz_512_reduce:
1556         movq    %r8, %rbx
1557         imulq   128+8(%rsp), %rbx
1558         movq    0(%rbp), %rax
1559         movl    \$8, %ecx
1560         jmp     .Lreduction_loop
1561
1562 .align  32
1563 .Lreduction_loop:
1564         mulq    %rbx
1565         movq    8(%rbp), %rax
1566         negq    %r8
1567         movq    %rdx, %r8
1568         adcq    \$0, %r8
1569
1570         mulq    %rbx
1571         addq    %rax, %r9
1572         movq    16(%rbp), %rax
1573         adcq    \$0, %rdx
1574         addq    %r9, %r8
1575         movq    %rdx, %r9
1576         adcq    \$0, %r9
1577
1578         mulq    %rbx
1579         addq    %rax, %r10
1580         movq    24(%rbp), %rax
1581         adcq    \$0, %rdx
1582         addq    %r10, %r9
1583         movq    %rdx, %r10
1584         adcq    \$0, %r10
1585
1586         mulq    %rbx
1587         addq    %rax, %r11
1588         movq    32(%rbp), %rax
1589         adcq    \$0, %rdx
1590         addq    %r11, %r10
1591          movq   128+8(%rsp), %rsi
1592         #movq   %rdx, %r11
1593         #adcq   \$0, %r11
1594         adcq    \$0, %rdx
1595         movq    %rdx, %r11
1596
1597         mulq    %rbx
1598         addq    %rax, %r12
1599         movq    40(%rbp), %rax
1600         adcq    \$0, %rdx
1601          imulq  %r8, %rsi
1602         addq    %r12, %r11
1603         movq    %rdx, %r12
1604         adcq    \$0, %r12
1605
1606         mulq    %rbx
1607         addq    %rax, %r13
1608         movq    48(%rbp), %rax
1609         adcq    \$0, %rdx
1610         addq    %r13, %r12
1611         movq    %rdx, %r13
1612         adcq    \$0, %r13
1613
1614         mulq    %rbx
1615         addq    %rax, %r14
1616         movq    56(%rbp), %rax
1617         adcq    \$0, %rdx
1618         addq    %r14, %r13
1619         movq    %rdx, %r14
1620         adcq    \$0, %r14
1621
1622         mulq    %rbx
1623          movq   %rsi, %rbx
1624         addq    %rax, %r15
1625          movq   0(%rbp), %rax
1626         adcq    \$0, %rdx
1627         addq    %r15, %r14
1628         movq    %rdx, %r15
1629         adcq    \$0, %r15
1630
1631         decl    %ecx
1632         jne     .Lreduction_loop
1633
1634         ret
1635 .size   __rsaz_512_reduce,.-__rsaz_512_reduce
1636 ___
1637 }
1638 if ($addx) {
1639         # __rsaz_512_reducex
1640         #
1641         # input:        %r8-%r15, %rbp - mod, 128(%rsp) - n0
1642         # output:       %r8-%r15
1643         # clobbers:     everything except %rbp and %rdi
1644 $code.=<<___;
1645 .type   __rsaz_512_reducex,\@abi-omnipotent
1646 .align  32
1647 __rsaz_512_reducex:
1648         #movq   128+8(%rsp), %rdx               # pull $n0
1649         imulq   %r8, %rdx
1650         xorq    %rsi, %rsi                      # cf=0,of=0
1651         movl    \$8, %ecx
1652         jmp     .Lreduction_loopx
1653
1654 .align  32
1655 .Lreduction_loopx:
1656         mov     %r8, %rbx
1657         mulx    0(%rbp), %rax, %r8
1658         adcx    %rbx, %rax
1659         adox    %r9, %r8
1660
1661         mulx    8(%rbp), %rax, %r9
1662         adcx    %rax, %r8
1663         adox    %r10, %r9
1664
1665         mulx    16(%rbp), %rbx, %r10
1666         adcx    %rbx, %r9
1667         adox    %r11, %r10
1668
1669         mulx    24(%rbp), %rbx, %r11
1670         adcx    %rbx, %r10
1671         adox    %r12, %r11
1672
1673         .byte   0xc4,0x62,0xe3,0xf6,0xa5,0x20,0x00,0x00,0x00    # mulx  32(%rbp), %rbx, %r12
1674          mov    %rdx, %rax
1675          mov    %r8, %rdx
1676         adcx    %rbx, %r11
1677         adox    %r13, %r12
1678
1679          mulx   128+8(%rsp), %rbx, %rdx
1680          mov    %rax, %rdx
1681
1682         mulx    40(%rbp), %rax, %r13
1683         adcx    %rax, %r12
1684         adox    %r14, %r13
1685
1686         .byte   0xc4,0x62,0xfb,0xf6,0xb5,0x30,0x00,0x00,0x00    # mulx  48(%rbp), %rax, %r14
1687         adcx    %rax, %r13
1688         adox    %r15, %r14
1689
1690         mulx    56(%rbp), %rax, %r15
1691          mov    %rbx, %rdx
1692         adcx    %rax, %r14
1693         adox    %rsi, %r15                      # %rsi is 0
1694         adcx    %rsi, %r15                      # cf=0
1695
1696         decl    %ecx                            # of=0
1697         jne     .Lreduction_loopx
1698
1699         ret
1700 .size   __rsaz_512_reducex,.-__rsaz_512_reducex
1701 ___
1702 }
1703 {       # __rsaz_512_subtract
1704         # input: %r8-%r15, %rdi - $out, %rbp - $mod, %rcx - mask
1705         # output:
1706         # clobbers: everything but %rdi, %rsi and %rbp
1707 $code.=<<___;
1708 .type   __rsaz_512_subtract,\@abi-omnipotent
1709 .align  32
1710 __rsaz_512_subtract:
1711         movq    %r8, ($out)
1712         movq    %r9, 8($out)
1713         movq    %r10, 16($out)
1714         movq    %r11, 24($out)
1715         movq    %r12, 32($out)
1716         movq    %r13, 40($out)
1717         movq    %r14, 48($out)
1718         movq    %r15, 56($out)
1719
1720         movq    0($mod), %r8
1721         movq    8($mod), %r9
1722         negq    %r8
1723         notq    %r9
1724         andq    %rcx, %r8
1725         movq    16($mod), %r10
1726         andq    %rcx, %r9
1727         notq    %r10
1728         movq    24($mod), %r11
1729         andq    %rcx, %r10
1730         notq    %r11
1731         movq    32($mod), %r12
1732         andq    %rcx, %r11
1733         notq    %r12
1734         movq    40($mod), %r13
1735         andq    %rcx, %r12
1736         notq    %r13
1737         movq    48($mod), %r14
1738         andq    %rcx, %r13
1739         notq    %r14
1740         movq    56($mod), %r15
1741         andq    %rcx, %r14
1742         notq    %r15
1743         andq    %rcx, %r15
1744
1745         addq    ($out), %r8
1746         adcq    8($out), %r9
1747         adcq    16($out), %r10
1748         adcq    24($out), %r11
1749         adcq    32($out), %r12
1750         adcq    40($out), %r13
1751         adcq    48($out), %r14
1752         adcq    56($out), %r15
1753
1754         movq    %r8, ($out)
1755         movq    %r9, 8($out)
1756         movq    %r10, 16($out)
1757         movq    %r11, 24($out)
1758         movq    %r12, 32($out)
1759         movq    %r13, 40($out)
1760         movq    %r14, 48($out)
1761         movq    %r15, 56($out)
1762
1763         ret
1764 .size   __rsaz_512_subtract,.-__rsaz_512_subtract
1765 ___
1766 }
1767 {       # __rsaz_512_mul
1768         #
1769         # input: %rsi - ap, %rbp - bp
1770         # output:
1771         # clobbers: everything
1772 my ($ap,$bp) = ("%rsi","%rbp");
1773 $code.=<<___;
1774 .type   __rsaz_512_mul,\@abi-omnipotent
1775 .align  32
1776 __rsaz_512_mul:
1777         leaq    8(%rsp), %rdi
1778
1779         movq    ($ap), %rax
1780         mulq    %rbx
1781         movq    %rax, (%rdi)
1782         movq    8($ap), %rax
1783         movq    %rdx, %r8
1784
1785         mulq    %rbx
1786         addq    %rax, %r8
1787         movq    16($ap), %rax
1788         movq    %rdx, %r9
1789         adcq    \$0, %r9
1790
1791         mulq    %rbx
1792         addq    %rax, %r9
1793         movq    24($ap), %rax
1794         movq    %rdx, %r10
1795         adcq    \$0, %r10
1796
1797         mulq    %rbx
1798         addq    %rax, %r10
1799         movq    32($ap), %rax
1800         movq    %rdx, %r11
1801         adcq    \$0, %r11
1802
1803         mulq    %rbx
1804         addq    %rax, %r11
1805         movq    40($ap), %rax
1806         movq    %rdx, %r12
1807         adcq    \$0, %r12
1808
1809         mulq    %rbx
1810         addq    %rax, %r12
1811         movq    48($ap), %rax
1812         movq    %rdx, %r13
1813         adcq    \$0, %r13
1814
1815         mulq    %rbx
1816         addq    %rax, %r13
1817         movq    56($ap), %rax
1818         movq    %rdx, %r14
1819         adcq    \$0, %r14
1820
1821         mulq    %rbx
1822         addq    %rax, %r14
1823          movq   ($ap), %rax
1824         movq    %rdx, %r15
1825         adcq    \$0, %r15
1826
1827         leaq    8($bp), $bp
1828         leaq    8(%rdi), %rdi
1829
1830         movl    \$7, %ecx
1831         jmp     .Loop_mul
1832
1833 .align  32
1834 .Loop_mul:
1835         movq    ($bp), %rbx
1836         mulq    %rbx
1837         addq    %rax, %r8
1838         movq    8($ap), %rax
1839         movq    %r8, (%rdi)
1840         movq    %rdx, %r8
1841         adcq    \$0, %r8
1842
1843         mulq    %rbx
1844         addq    %rax, %r9
1845         movq    16($ap), %rax
1846         adcq    \$0, %rdx
1847         addq    %r9, %r8
1848         movq    %rdx, %r9
1849         adcq    \$0, %r9
1850
1851         mulq    %rbx
1852         addq    %rax, %r10
1853         movq    24($ap), %rax
1854         adcq    \$0, %rdx
1855         addq    %r10, %r9
1856         movq    %rdx, %r10
1857         adcq    \$0, %r10
1858
1859         mulq    %rbx
1860         addq    %rax, %r11
1861         movq    32($ap), %rax
1862         adcq    \$0, %rdx
1863         addq    %r11, %r10
1864         movq    %rdx, %r11
1865         adcq    \$0, %r11
1866
1867         mulq    %rbx
1868         addq    %rax, %r12
1869         movq    40($ap), %rax
1870         adcq    \$0, %rdx
1871         addq    %r12, %r11
1872         movq    %rdx, %r12
1873         adcq    \$0, %r12
1874
1875         mulq    %rbx
1876         addq    %rax, %r13
1877         movq    48($ap), %rax
1878         adcq    \$0, %rdx
1879         addq    %r13, %r12
1880         movq    %rdx, %r13
1881         adcq    \$0, %r13
1882
1883         mulq    %rbx
1884         addq    %rax, %r14
1885         movq    56($ap), %rax
1886         adcq    \$0, %rdx
1887         addq    %r14, %r13
1888         movq    %rdx, %r14
1889          leaq   8($bp), $bp
1890         adcq    \$0, %r14
1891
1892         mulq    %rbx
1893         addq    %rax, %r15
1894          movq   ($ap), %rax
1895         adcq    \$0, %rdx
1896         addq    %r15, %r14
1897         movq    %rdx, %r15
1898         adcq    \$0, %r15
1899
1900         leaq    8(%rdi), %rdi
1901
1902         decl    %ecx
1903         jnz     .Loop_mul
1904
1905         movq    %r8, (%rdi)
1906         movq    %r9, 8(%rdi)
1907         movq    %r10, 16(%rdi)
1908         movq    %r11, 24(%rdi)
1909         movq    %r12, 32(%rdi)
1910         movq    %r13, 40(%rdi)
1911         movq    %r14, 48(%rdi)
1912         movq    %r15, 56(%rdi)
1913
1914         ret
1915 .size   __rsaz_512_mul,.-__rsaz_512_mul
1916 ___
1917 }
1918 if ($addx) {
1919         # __rsaz_512_mulx
1920         #
1921         # input: %rsi - ap, %rbp - bp
1922         # output:
1923         # clobbers: everything
1924 my ($ap,$bp,$zero) = ("%rsi","%rbp","%rdi");
1925 $code.=<<___;
1926 .type   __rsaz_512_mulx,\@abi-omnipotent
1927 .align  32
1928 __rsaz_512_mulx:
1929         mulx    ($ap), %rbx, %r8        # initial %rdx preloaded by caller
1930         mov     \$-6, %rcx
1931
1932         mulx    8($ap), %rax, %r9
1933         movq    %rbx, 8(%rsp)
1934
1935         mulx    16($ap), %rbx, %r10
1936         adc     %rax, %r8
1937
1938         mulx    24($ap), %rax, %r11
1939         adc     %rbx, %r9
1940
1941         mulx    32($ap), %rbx, %r12
1942         adc     %rax, %r10
1943
1944         mulx    40($ap), %rax, %r13
1945         adc     %rbx, %r11
1946
1947         mulx    48($ap), %rbx, %r14
1948         adc     %rax, %r12
1949
1950         mulx    56($ap), %rax, %r15
1951          mov    8($bp), %rdx
1952         adc     %rbx, %r13
1953         adc     %rax, %r14
1954         adc     \$0, %r15
1955
1956         xor     $zero, $zero            # cf=0,of=0
1957         jmp     .Loop_mulx
1958
1959 .align  32
1960 .Loop_mulx:
1961         movq    %r8, %rbx
1962         mulx    ($ap), %rax, %r8
1963         adcx    %rax, %rbx
1964         adox    %r9, %r8
1965
1966         mulx    8($ap), %rax, %r9
1967         adcx    %rax, %r8
1968         adox    %r10, %r9
1969
1970         mulx    16($ap), %rax, %r10
1971         adcx    %rax, %r9
1972         adox    %r11, %r10
1973
1974         mulx    24($ap), %rax, %r11
1975         adcx    %rax, %r10
1976         adox    %r12, %r11
1977
1978         .byte   0x3e,0xc4,0x62,0xfb,0xf6,0xa6,0x20,0x00,0x00,0x00       # mulx  32($ap), %rax, %r12
1979         adcx    %rax, %r11
1980         adox    %r13, %r12
1981
1982         mulx    40($ap), %rax, %r13
1983         adcx    %rax, %r12
1984         adox    %r14, %r13
1985
1986         mulx    48($ap), %rax, %r14
1987         adcx    %rax, %r13
1988         adox    %r15, %r14
1989
1990         mulx    56($ap), %rax, %r15
1991          movq   64($bp,%rcx,8), %rdx
1992          movq   %rbx, 8+64-8(%rsp,%rcx,8)
1993         adcx    %rax, %r14
1994         adox    $zero, %r15
1995         adcx    $zero, %r15             # cf=0
1996
1997         inc     %rcx                    # of=0
1998         jnz     .Loop_mulx
1999
2000         movq    %r8, %rbx
2001         mulx    ($ap), %rax, %r8
2002         adcx    %rax, %rbx
2003         adox    %r9, %r8
2004
2005         .byte   0xc4,0x62,0xfb,0xf6,0x8e,0x08,0x00,0x00,0x00    # mulx  8($ap), %rax, %r9
2006         adcx    %rax, %r8
2007         adox    %r10, %r9
2008
2009         .byte   0xc4,0x62,0xfb,0xf6,0x96,0x10,0x00,0x00,0x00    # mulx  16($ap), %rax, %r10
2010         adcx    %rax, %r9
2011         adox    %r11, %r10
2012
2013         mulx    24($ap), %rax, %r11
2014         adcx    %rax, %r10
2015         adox    %r12, %r11
2016
2017         mulx    32($ap), %rax, %r12
2018         adcx    %rax, %r11
2019         adox    %r13, %r12
2020
2021         mulx    40($ap), %rax, %r13
2022         adcx    %rax, %r12
2023         adox    %r14, %r13
2024
2025         .byte   0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($ap), %rax, %r14
2026         adcx    %rax, %r13
2027         adox    %r15, %r14
2028
2029         .byte   0xc4,0x62,0xfb,0xf6,0xbe,0x38,0x00,0x00,0x00    # mulx  56($ap), %rax, %r15
2030         adcx    %rax, %r14
2031         adox    $zero, %r15
2032         adcx    $zero, %r15
2033
2034         mov     %rbx, 8+64-8(%rsp)
2035         mov     %r8, 8+64(%rsp)
2036         mov     %r9, 8+64+8(%rsp)
2037         mov     %r10, 8+64+16(%rsp)
2038         mov     %r11, 8+64+24(%rsp)
2039         mov     %r12, 8+64+32(%rsp)
2040         mov     %r13, 8+64+40(%rsp)
2041         mov     %r14, 8+64+48(%rsp)
2042         mov     %r15, 8+64+56(%rsp)
2043
2044         ret
2045 .size   __rsaz_512_mulx,.-__rsaz_512_mulx
2046 ___
2047 }
2048 {
2049 my ($out,$inp,$power)= $win64 ? ("%rcx","%rdx","%r8d") : ("%rdi","%rsi","%edx");
2050 $code.=<<___;
2051 .globl  rsaz_512_scatter4
2052 .type   rsaz_512_scatter4,\@abi-omnipotent
2053 .align  16
2054 rsaz_512_scatter4:
2055         leaq    ($out,$power,8), $out
2056         movl    \$8, %r9d
2057         jmp     .Loop_scatter
2058 .align  16
2059 .Loop_scatter:
2060         movq    ($inp), %rax
2061         leaq    8($inp), $inp
2062         movq    %rax, ($out)
2063         leaq    128($out), $out
2064         decl    %r9d
2065         jnz     .Loop_scatter
2066         ret
2067 .size   rsaz_512_scatter4,.-rsaz_512_scatter4
2068
2069 .globl  rsaz_512_gather4
2070 .type   rsaz_512_gather4,\@abi-omnipotent
2071 .align  16
2072 rsaz_512_gather4:
2073 ___
2074 $code.=<<___    if ($win64);
2075 .LSEH_begin_rsaz_512_gather4:
2076         .byte   0x48,0x81,0xec,0xa8,0x00,0x00,0x00      # sub    $0xa8,%rsp
2077         .byte   0x0f,0x29,0x34,0x24                     # movaps %xmm6,(%rsp)
2078         .byte   0x0f,0x29,0x7c,0x24,0x10                # movaps %xmm7,0x10(%rsp)
2079         .byte   0x44,0x0f,0x29,0x44,0x24,0x20           # movaps %xmm8,0x20(%rsp)
2080         .byte   0x44,0x0f,0x29,0x4c,0x24,0x30           # movaps %xmm9,0x30(%rsp)
2081         .byte   0x44,0x0f,0x29,0x54,0x24,0x40           # movaps %xmm10,0x40(%rsp)
2082         .byte   0x44,0x0f,0x29,0x5c,0x24,0x50           # movaps %xmm11,0x50(%rsp)
2083         .byte   0x44,0x0f,0x29,0x64,0x24,0x60           # movaps %xmm12,0x60(%rsp)
2084         .byte   0x44,0x0f,0x29,0x6c,0x24,0x70           # movaps %xmm13,0x70(%rsp)
2085         .byte   0x44,0x0f,0x29,0xb4,0x24,0x80,0,0,0     # movaps %xmm14,0x80(%rsp)
2086         .byte   0x44,0x0f,0x29,0xbc,0x24,0x90,0,0,0     # movaps %xmm15,0x90(%rsp)
2087 ___
2088 $code.=<<___;
2089         movd    $power,%xmm8
2090         movdqa  .Linc+16(%rip),%xmm1    # 00000002000000020000000200000002
2091         movdqa  .Linc(%rip),%xmm0       # 00000001000000010000000000000000
2092
2093         pshufd  \$0,%xmm8,%xmm8         # broadcast $power
2094         movdqa  %xmm1,%xmm7
2095         movdqa  %xmm1,%xmm2
2096 ___
2097 ########################################################################
2098 # calculate mask by comparing 0..15 to $power
2099 #
2100 for($i=0;$i<4;$i++) {
2101 $code.=<<___;
2102         paddd   %xmm`$i`,%xmm`$i+1`
2103         pcmpeqd %xmm8,%xmm`$i`
2104         movdqa  %xmm7,%xmm`$i+3`
2105 ___
2106 }
2107 for(;$i<7;$i++) {
2108 $code.=<<___;
2109         paddd   %xmm`$i`,%xmm`$i+1`
2110         pcmpeqd %xmm8,%xmm`$i`
2111 ___
2112 }
2113 $code.=<<___;
2114         pcmpeqd %xmm8,%xmm7
2115         movl    \$8, %r9d
2116         jmp     .Loop_gather
2117 .align  16
2118 .Loop_gather:
2119         movdqa  16*0($inp),%xmm8
2120         movdqa  16*1($inp),%xmm9
2121         movdqa  16*2($inp),%xmm10
2122         movdqa  16*3($inp),%xmm11
2123         pand    %xmm0,%xmm8
2124         movdqa  16*4($inp),%xmm12
2125         pand    %xmm1,%xmm9
2126         movdqa  16*5($inp),%xmm13
2127         pand    %xmm2,%xmm10
2128         movdqa  16*6($inp),%xmm14
2129         pand    %xmm3,%xmm11
2130         movdqa  16*7($inp),%xmm15
2131         leaq    128($inp), $inp
2132         pand    %xmm4,%xmm12
2133         pand    %xmm5,%xmm13
2134         pand    %xmm6,%xmm14
2135         pand    %xmm7,%xmm15
2136         por     %xmm10,%xmm8
2137         por     %xmm11,%xmm9
2138         por     %xmm12,%xmm8
2139         por     %xmm13,%xmm9
2140         por     %xmm14,%xmm8
2141         por     %xmm15,%xmm9
2142
2143         por     %xmm9,%xmm8
2144         pshufd  \$0x4e,%xmm8,%xmm9
2145         por     %xmm9,%xmm8
2146         movq    %xmm8,($out)
2147         leaq    8($out), $out
2148         decl    %r9d
2149         jnz     .Loop_gather
2150 ___
2151 $code.=<<___    if ($win64);
2152         movaps  0x00(%rsp),%xmm6
2153         movaps  0x10(%rsp),%xmm7
2154         movaps  0x20(%rsp),%xmm8
2155         movaps  0x30(%rsp),%xmm9
2156         movaps  0x40(%rsp),%xmm10
2157         movaps  0x50(%rsp),%xmm11
2158         movaps  0x60(%rsp),%xmm12
2159         movaps  0x70(%rsp),%xmm13
2160         movaps  0x80(%rsp),%xmm14
2161         movaps  0x90(%rsp),%xmm15
2162         add     \$0xa8,%rsp
2163 ___
2164 $code.=<<___;
2165         ret
2166 .LSEH_end_rsaz_512_gather4:
2167 .size   rsaz_512_gather4,.-rsaz_512_gather4
2168
2169 .align  64
2170 .Linc:
2171         .long   0,0, 1,1
2172         .long   2,2, 2,2
2173 ___
2174 }
2175
2176 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
2177 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
2178 if ($win64) {
2179 $rec="%rcx";
2180 $frame="%rdx";
2181 $context="%r8";
2182 $disp="%r9";
2183
2184 $code.=<<___;
2185 .extern __imp_RtlVirtualUnwind
2186 .type   se_handler,\@abi-omnipotent
2187 .align  16
2188 se_handler:
2189         push    %rsi
2190         push    %rdi
2191         push    %rbx
2192         push    %rbp
2193         push    %r12
2194         push    %r13
2195         push    %r14
2196         push    %r15
2197         pushfq
2198         sub     \$64,%rsp
2199
2200         mov     120($context),%rax      # pull context->Rax
2201         mov     248($context),%rbx      # pull context->Rip
2202
2203         mov     8($disp),%rsi           # disp->ImageBase
2204         mov     56($disp),%r11          # disp->HandlerData
2205
2206         mov     0(%r11),%r10d           # HandlerData[0]
2207         lea     (%rsi,%r10),%r10        # end of prologue label
2208         cmp     %r10,%rbx               # context->Rip<end of prologue label
2209         jb      .Lcommon_seh_tail
2210
2211         mov     152($context),%rax      # pull context->Rsp
2212
2213         mov     4(%r11),%r10d           # HandlerData[1]
2214         lea     (%rsi,%r10),%r10        # epilogue label
2215         cmp     %r10,%rbx               # context->Rip>=epilogue label
2216         jae     .Lcommon_seh_tail
2217
2218         lea     128+24+48(%rax),%rax
2219
2220         lea     .Lmul_gather4_epilogue(%rip),%rbx
2221         cmp     %r10,%rbx
2222         jne     .Lse_not_in_mul_gather4
2223
2224         lea     0xb0(%rax),%rax
2225
2226         lea     -48-0xa8(%rax),%rsi
2227         lea     512($context),%rdi
2228         mov     \$20,%ecx
2229         .long   0xa548f3fc              # cld; rep movsq
2230
2231 .Lse_not_in_mul_gather4:
2232         mov     -8(%rax),%rbx
2233         mov     -16(%rax),%rbp
2234         mov     -24(%rax),%r12
2235         mov     -32(%rax),%r13
2236         mov     -40(%rax),%r14
2237         mov     -48(%rax),%r15
2238         mov     %rbx,144($context)      # restore context->Rbx
2239         mov     %rbp,160($context)      # restore context->Rbp
2240         mov     %r12,216($context)      # restore context->R12
2241         mov     %r13,224($context)      # restore context->R13
2242         mov     %r14,232($context)      # restore context->R14
2243         mov     %r15,240($context)      # restore context->R15
2244
2245 .Lcommon_seh_tail:
2246         mov     8(%rax),%rdi
2247         mov     16(%rax),%rsi
2248         mov     %rax,152($context)      # restore context->Rsp
2249         mov     %rsi,168($context)      # restore context->Rsi
2250         mov     %rdi,176($context)      # restore context->Rdi
2251
2252         mov     40($disp),%rdi          # disp->ContextRecord
2253         mov     $context,%rsi           # context
2254         mov     \$154,%ecx              # sizeof(CONTEXT)
2255         .long   0xa548f3fc              # cld; rep movsq
2256
2257         mov     $disp,%rsi
2258         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
2259         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
2260         mov     0(%rsi),%r8             # arg3, disp->ControlPc
2261         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
2262         mov     40(%rsi),%r10           # disp->ContextRecord
2263         lea     56(%rsi),%r11           # &disp->HandlerData
2264         lea     24(%rsi),%r12           # &disp->EstablisherFrame
2265         mov     %r10,32(%rsp)           # arg5
2266         mov     %r11,40(%rsp)           # arg6
2267         mov     %r12,48(%rsp)           # arg7
2268         mov     %rcx,56(%rsp)           # arg8, (NULL)
2269         call    *__imp_RtlVirtualUnwind(%rip)
2270
2271         mov     \$1,%eax                # ExceptionContinueSearch
2272         add     \$64,%rsp
2273         popfq
2274         pop     %r15
2275         pop     %r14
2276         pop     %r13
2277         pop     %r12
2278         pop     %rbp
2279         pop     %rbx
2280         pop     %rdi
2281         pop     %rsi
2282         ret
2283 .size   se_handler,.-se_handler
2284
2285 .section        .pdata
2286 .align  4
2287         .rva    .LSEH_begin_rsaz_512_sqr
2288         .rva    .LSEH_end_rsaz_512_sqr
2289         .rva    .LSEH_info_rsaz_512_sqr
2290
2291         .rva    .LSEH_begin_rsaz_512_mul
2292         .rva    .LSEH_end_rsaz_512_mul
2293         .rva    .LSEH_info_rsaz_512_mul
2294
2295         .rva    .LSEH_begin_rsaz_512_mul_gather4
2296         .rva    .LSEH_end_rsaz_512_mul_gather4
2297         .rva    .LSEH_info_rsaz_512_mul_gather4
2298
2299         .rva    .LSEH_begin_rsaz_512_mul_scatter4
2300         .rva    .LSEH_end_rsaz_512_mul_scatter4
2301         .rva    .LSEH_info_rsaz_512_mul_scatter4
2302
2303         .rva    .LSEH_begin_rsaz_512_mul_by_one
2304         .rva    .LSEH_end_rsaz_512_mul_by_one
2305         .rva    .LSEH_info_rsaz_512_mul_by_one
2306
2307         .rva    .LSEH_begin_rsaz_512_gather4
2308         .rva    .LSEH_end_rsaz_512_gather4
2309         .rva    .LSEH_info_rsaz_512_gather4
2310
2311 .section        .xdata
2312 .align  8
2313 .LSEH_info_rsaz_512_sqr:
2314         .byte   9,0,0,0
2315         .rva    se_handler
2316         .rva    .Lsqr_body,.Lsqr_epilogue                       # HandlerData[]
2317 .LSEH_info_rsaz_512_mul:
2318         .byte   9,0,0,0
2319         .rva    se_handler
2320         .rva    .Lmul_body,.Lmul_epilogue                       # HandlerData[]
2321 .LSEH_info_rsaz_512_mul_gather4:
2322         .byte   9,0,0,0
2323         .rva    se_handler
2324         .rva    .Lmul_gather4_body,.Lmul_gather4_epilogue       # HandlerData[]
2325 .LSEH_info_rsaz_512_mul_scatter4:
2326         .byte   9,0,0,0
2327         .rva    se_handler
2328         .rva    .Lmul_scatter4_body,.Lmul_scatter4_epilogue     # HandlerData[]
2329 .LSEH_info_rsaz_512_mul_by_one:
2330         .byte   9,0,0,0
2331         .rva    se_handler
2332         .rva    .Lmul_by_one_body,.Lmul_by_one_epilogue         # HandlerData[]
2333 .LSEH_info_rsaz_512_gather4:
2334         .byte   0x01,0x46,0x16,0x00
2335         .byte   0x46,0xf8,0x09,0x00     #vmovaps 0x90(rsp),xmm15
2336         .byte   0x3d,0xe8,0x08,0x00     #vmovaps 0x80(rsp),xmm14
2337         .byte   0x34,0xd8,0x07,0x00     #vmovaps 0x70(rsp),xmm13
2338         .byte   0x2e,0xc8,0x06,0x00     #vmovaps 0x60(rsp),xmm12
2339         .byte   0x28,0xb8,0x05,0x00     #vmovaps 0x50(rsp),xmm11
2340         .byte   0x22,0xa8,0x04,0x00     #vmovaps 0x40(rsp),xmm10
2341         .byte   0x1c,0x98,0x03,0x00     #vmovaps 0x30(rsp),xmm9
2342         .byte   0x16,0x88,0x02,0x00     #vmovaps 0x20(rsp),xmm8
2343         .byte   0x10,0x78,0x01,0x00     #vmovaps 0x10(rsp),xmm7
2344         .byte   0x0b,0x68,0x00,0x00     #vmovaps 0x00(rsp),xmm6
2345         .byte   0x07,0x01,0x15,0x00     #sub     rsp,0xa8
2346 ___
2347 }
2348
2349 $code =~ s/\`([^\`]*)\`/eval $1/gem;
2350 print $code;
2351 close STDOUT;