crypto/sha/asm/sha1-x86_64.pl

   1 #!/usr/bin/env perl
   2 #
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@fy.chalmers.se> 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 # sha1_block procedure for x86_64.
  11 #
  12 # It was brought to my attention that on EM64T compiler-generated code
  13 # was far behind 32-bit assembler implementation. This is unlike on
  14 # Opteron where compiler-generated code was only 15% behind 32-bit
  15 # assembler, which originally made it hard to motivate the effort.
  16 # There was suggestion to mechanically translate 32-bit code, but I
  17 # dismissed it, reasoning that x86_64 offers enough register bank
  18 # capacity to fully utilize SHA-1 parallelism. Therefore this fresh
  19 # implementation:-) However! While 64-bit code does perform better
  20 # on Opteron, I failed to beat 32-bit assembler on EM64T core. Well,
  21 # x86_64 does offer larger *addressable* bank, but out-of-order core
  22 # reaches for even more registers through dynamic aliasing, and EM64T
  23 # core must have managed to run-time optimize even 32-bit code just as
  24 # good as 64-bit one. Performance improvement is summarized in the
  25 # following table:
  26 #
  27 #               gcc 3.4         32-bit asm      cycles/byte
  28 # Opteron       +45%            +20%            6.8
  29 # Xeon P4       +65%            +0%             9.9
  30 # Core2         +60%            +10%            7.0
  31
  32 # August 2009.
  33 #
  34 # The code was revised to minimize code size and to maximize
  35 # "distance" between instructions producing input to 'lea'
  36 # instruction and the 'lea' instruction itself, which is essential
  37 # for Intel Atom core.
  38
  39 # October 2010.
  40 #
  41 # Add SSSE3, Supplemental[!] SSE3, implementation. The idea behind it
  42 # is to offload message schedule denoted by Wt in NIST specification,
  43 # or Xupdate in OpenSSL source, to SIMD unit. See sha1-586.pl module
  44 # for background and implementation details. The only difference from
  45 # 32-bit code is that 64-bit code doesn't have to spill @X[] elements
  46 # to free temporary registers.
  47
  48 # April 2011.
  49 #
  50 # Add AVX code path. See sha1-586.pl for further information.
  51
  52 ######################################################################
  53 # Current performance is summarized in following table. Numbers are
  54 # CPU clock cycles spent to process single byte (less is better).
  55 #
  56 #               x86_64          SSSE3           AVX
  57 # P4            9.8             -
  58 # Opteron       6.6             -
  59 # Core2         6.7             6.2/+8%         -
  60 # Atom          11.0            9.5/+15%        -
  61 # Westmere      7.1             5.5/+29%        -
  62 # Sandy Bridge  7.9             6.2/+28%        5.1/+54%
  63 # Ivy Bridge    6.4             4.7/+35%        4.6/+37%
  64 # Bulldozer     10.9            6.0/+82%
  65 # VIA Nano      10.2            7.4/+38%
  66
  67 $flavour = shift;
  68 $output  = shift;
  69 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
  70
  71 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
  72
  73 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  74 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
  75 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
  76 die "can't locate x86_64-xlate.pl";
  77
  78 $avx=1 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
  79                 =~ /GNU assembler version ([2-9]\.[0-9]+)/ &&
  80            $1>=2.19);
  81 $avx=1 if (!$avx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
  82            `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/ &&
  83            $1>=2.09);
  84 $avx=1 if (!$avx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
  85            `ml64 2>&1` =~ /Version ([0-9]+)\./ &&
  86            $1>=10);
  87
  88 open OUT,"| \"$^X\" $xlate $flavour $output";
  89 *STDOUT=*OUT;
  90
  91 $ctx="%rdi";    # 1st arg
  92 $inp="%rsi";    # 2nd arg
  93 $num="%rdx";    # 3rd arg
  94
  95 # reassign arguments in order to produce more compact code
  96 $ctx="%r8";
  97 $inp="%r9";
  98 $num="%r10";
  99
 100 $t0="%eax";
 101 $t1="%ebx";
 102 $t2="%ecx";
 103 @xi=("%edx","%ebp");
 104 $A="%esi";
 105 $B="%edi";
 106 $C="%r11d";
 107 $D="%r12d";
 108 $E="%r13d";
 109
 110 @V=($A,$B,$C,$D,$E);
 111
 112 sub BODY_00_19 {
 113 my ($i,$a,$b,$c,$d,$e)=@_;
 114 my $j=$i+1;
 115 $code.=<<___ if ($i==0);
 116         mov     `4*$i`($inp),$xi[0]
 117         bswap   $xi[0]
 118         mov     $xi[0],`4*$i`(%rsp)
 119 ___
 120 $code.=<<___ if ($i<15);
 121         mov     $c,$t0
 122         mov     `4*$j`($inp),$xi[1]
 123         mov     $a,$t2
 124         xor     $d,$t0
 125         bswap   $xi[1]
 126         rol     \$5,$t2
 127         lea     0x5a827999($xi[0],$e),$e
 128         and     $b,$t0
 129         mov     $xi[1],`4*$j`(%rsp)
 130         add     $t2,$e
 131         xor     $d,$t0
 132         rol     \$30,$b
 133         add     $t0,$e
 134 ___
 135 $code.=<<___ if ($i>=15);
 136         mov     `4*($j%16)`(%rsp),$xi[1]
 137         mov     $c,$t0
 138         mov     $a,$t2
 139         xor     `4*(($j+2)%16)`(%rsp),$xi[1]
 140         xor     $d,$t0
 141         rol     \$5,$t2
 142         xor     `4*(($j+8)%16)`(%rsp),$xi[1]
 143         and     $b,$t0
 144         lea     0x5a827999($xi[0],$e),$e
 145         xor     `4*(($j+13)%16)`(%rsp),$xi[1]
 146         xor     $d,$t0
 147         rol     \$1,$xi[1]
 148         add     $t2,$e
 149         rol     \$30,$b
 150         mov     $xi[1],`4*($j%16)`(%rsp)
 151         add     $t0,$e
 152 ___
 153 unshift(@xi,pop(@xi));
 154 }
 155
 156 sub BODY_20_39 {
 157 my ($i,$a,$b,$c,$d,$e)=@_;
 158 my $j=$i+1;
 159 my $K=($i<40)?0x6ed9eba1:0xca62c1d6;
 160 $code.=<<___ if ($i<79);
 161         mov     `4*($j%16)`(%rsp),$xi[1]
 162         mov     $c,$t0
 163         mov     $a,$t2
 164         xor     `4*(($j+2)%16)`(%rsp),$xi[1]
 165         xor     $b,$t0
 166         rol     \$5,$t2
 167         lea     $K($xi[0],$e),$e
 168         xor     `4*(($j+8)%16)`(%rsp),$xi[1]
 169         xor     $d,$t0
 170         add     $t2,$e
 171         xor     `4*(($j+13)%16)`(%rsp),$xi[1]
 172         rol     \$30,$b
 173         add     $t0,$e
 174         rol     \$1,$xi[1]
 175 ___
 176 $code.=<<___ if ($i<76);
 177         mov     $xi[1],`4*($j%16)`(%rsp)
 178 ___
 179 $code.=<<___ if ($i==79);
 180         mov     $c,$t0
 181         mov     $a,$t2
 182         xor     $b,$t0
 183         lea     $K($xi[0],$e),$e
 184         rol     \$5,$t2
 185         xor     $d,$t0
 186         add     $t2,$e
 187         rol     \$30,$b
 188         add     $t0,$e
 189 ___
 190 unshift(@xi,pop(@xi));
 191 }
 192
 193 sub BODY_40_59 {
 194 my ($i,$a,$b,$c,$d,$e)=@_;
 195 my $j=$i+1;
 196 $code.=<<___;
 197         mov     `4*($j%16)`(%rsp),$xi[1]
 198         mov     $c,$t0
 199         mov     $c,$t1
 200         xor     `4*(($j+2)%16)`(%rsp),$xi[1]
 201         and     $d,$t0
 202         mov     $a,$t2
 203         xor     `4*(($j+8)%16)`(%rsp),$xi[1]
 204         xor     $d,$t1
 205         lea     0x8f1bbcdc($xi[0],$e),$e
 206         rol     \$5,$t2
 207         xor     `4*(($j+13)%16)`(%rsp),$xi[1]
 208         add     $t0,$e
 209         and     $b,$t1
 210         rol     \$1,$xi[1]
 211         add     $t1,$e
 212         rol     \$30,$b
 213         mov     $xi[1],`4*($j%16)`(%rsp)
 214         add     $t2,$e
 215 ___
 216 unshift(@xi,pop(@xi));
 217 }
 218
 219 $code.=<<___;
 220 .text
 221 .extern OPENSSL_ia32cap_P
 222
 223 .globl  sha1_block_data_order
 224 .type   sha1_block_data_order,\@function,3
 225 .align  16
 226 sha1_block_data_order:
 227         mov     OPENSSL_ia32cap_P+0(%rip),%r9d
 228         mov     OPENSSL_ia32cap_P+4(%rip),%r8d
 229         test    \$`1<<9`,%r8d           # check SSSE3 bit
 230         jz      .Lialu
 231 ___
 232 $code.=<<___ if ($avx);
 233         and     \$`1<<28`,%r8d          # mask AVX bit
 234         and     \$`1<<30`,%r9d          # mask "Intel CPU" bit
 235         or      %r9d,%r8d
 236         cmp     \$`1<<28|1<<30`,%r8d
 237         je      _avx_shortcut
 238 ___
 239 $code.=<<___;
 240         jmp     _ssse3_shortcut
 241
 242 .align  16
 243 .Lialu:
 244         push    %rbx
 245         push    %rbp
 246         push    %r12
 247         push    %r13
 248         mov     %rsp,%r11
 249         mov     %rdi,$ctx       # reassigned argument
 250         sub     \$`8+16*4`,%rsp
 251         mov     %rsi,$inp       # reassigned argument
 252         and     \$-64,%rsp
 253         mov     %rdx,$num       # reassigned argument
 254         mov     %r11,`16*4`(%rsp)
 255 .Lprologue:
 256
 257         mov     0($ctx),$A
 258         mov     4($ctx),$B
 259         mov     8($ctx),$C
 260         mov     12($ctx),$D
 261         mov     16($ctx),$E
 262         jmp     .Lloop
 263
 264 .align  16
 265 .Lloop:
 266 ___
 267 for($i=0;$i<20;$i++)    { &BODY_00_19($i,@V); unshift(@V,pop(@V)); }
 268 for(;$i<40;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 269 for(;$i<60;$i++)        { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
 270 for(;$i<80;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 271 $code.=<<___;
 272         add     0($ctx),$A
 273         add     4($ctx),$B
 274         add     8($ctx),$C
 275         add     12($ctx),$D
 276         add     16($ctx),$E
 277         mov     $A,0($ctx)
 278         mov     $B,4($ctx)
 279         mov     $C,8($ctx)
 280         mov     $D,12($ctx)
 281         mov     $E,16($ctx)
 282
 283         sub     \$1,$num
 284         lea     `16*4`($inp),$inp
 285         jnz     .Lloop
 286
 287         mov     `16*4`(%rsp),%rsi
 288         mov     (%rsi),%r13
 289         mov     8(%rsi),%r12
 290         mov     16(%rsi),%rbp
 291         mov     24(%rsi),%rbx
 292         lea     32(%rsi),%rsp
 293 .Lepilogue:
 294         ret
 295 .size   sha1_block_data_order,.-sha1_block_data_order
 296 ___
 297 {{{
 298 my $Xi=4;
 299 my @X=map("%xmm$_",(4..7,0..3));
 300 my @Tx=map("%xmm$_",(8..10));
 301 my @V=($A,$B,$C,$D,$E)=("%eax","%ebx","%ecx","%edx","%ebp");    # size optimization
 302 my @T=("%esi","%edi");
 303 my $j=0;
 304 my $K_XX_XX="%r11";
 305
 306 my $_rol=sub { &rol(@_) };
 307 my $_ror=sub { &ror(@_) };
 308
 309 $code.=<<___;
 310 .type   sha1_block_data_order_ssse3,\@function,3
 311 .align  16
 312 sha1_block_data_order_ssse3:
 313 _ssse3_shortcut:
 314         push    %rbx
 315         push    %rbp
 316         push    %r12
 317         lea     `-64-($win64?5*16:0)`(%rsp),%rsp
 318 ___
 319 $code.=<<___ if ($win64);
 320         movaps  %xmm6,64+0(%rsp)
 321         movaps  %xmm7,64+16(%rsp)
 322         movaps  %xmm8,64+32(%rsp)
 323         movaps  %xmm9,64+48(%rsp)
 324         movaps  %xmm10,64+64(%rsp)
 325 .Lprologue_ssse3:
 326 ___
 327 $code.=<<___;
 328         mov     %rdi,$ctx       # reassigned argument
 329         mov     %rsi,$inp       # reassigned argument
 330         mov     %rdx,$num       # reassigned argument
 331
 332         shl     \$6,$num
 333         add     $inp,$num
 334         lea     K_XX_XX(%rip),$K_XX_XX
 335
 336         mov     0($ctx),$A              # load context
 337         mov     4($ctx),$B
 338         mov     8($ctx),$C
 339         mov     12($ctx),$D
 340         mov     $B,@T[0]                # magic seed
 341         mov     16($ctx),$E
 342
 343         movdqa  64($K_XX_XX),@X[2]      # pbswap mask
 344         movdqa  0($K_XX_XX),@Tx[1]      # K_00_19
 345         movdqu  0($inp),@X[-4&7]        # load input to %xmm[0-3]
 346         movdqu  16($inp),@X[-3&7]
 347         movdqu  32($inp),@X[-2&7]
 348         movdqu  48($inp),@X[-1&7]
 349         pshufb  @X[2],@X[-4&7]          # byte swap
 350         add     \$64,$inp
 351         pshufb  @X[2],@X[-3&7]
 352         pshufb  @X[2],@X[-2&7]
 353         pshufb  @X[2],@X[-1&7]
 354         paddd   @Tx[1],@X[-4&7]         # add K_00_19
 355         paddd   @Tx[1],@X[-3&7]
 356         paddd   @Tx[1],@X[-2&7]
 357         movdqa  @X[-4&7],0(%rsp)        # X[]+K xfer to IALU
 358         psubd   @Tx[1],@X[-4&7]         # restore X[]
 359         movdqa  @X[-3&7],16(%rsp)
 360         psubd   @Tx[1],@X[-3&7]
 361         movdqa  @X[-2&7],32(%rsp)
 362         psubd   @Tx[1],@X[-2&7]
 363         jmp     .Loop_ssse3
 364 ___
 365
 366 sub AUTOLOAD()          # thunk [simplified] 32-bit style perlasm
 367 { my $opcode = $AUTOLOAD; $opcode =~ s/.*:://;
 368   my $arg = pop;
 369     $arg = "\$$arg" if ($arg*1 eq $arg);
 370     $code .= "\t$opcode\t".join(',',$arg,reverse @_)."\n";
 371 }
 372
 373 sub Xupdate_ssse3_16_31()               # recall that $Xi starts wtih 4
 374 { use integer;
 375   my $body = shift;
 376   my @insns = (&$body,&$body,&$body,&$body);    # 40 instructions
 377   my ($a,$b,$c,$d,$e);
 378
 379         &movdqa (@X[0],@X[-3&7]);
 380          eval(shift(@insns));
 381          eval(shift(@insns));
 382         &movdqa (@Tx[0],@X[-1&7]);
 383         &palignr(@X[0],@X[-4&7],8);     # compose "X[-14]" in "X[0]"
 384          eval(shift(@insns));
 385          eval(shift(@insns));
 386
 387           &paddd        (@Tx[1],@X[-1&7]);
 388          eval(shift(@insns));
 389          eval(shift(@insns));
 390         &psrldq (@Tx[0],4);             # "X[-3]", 3 dwords
 391          eval(shift(@insns));
 392          eval(shift(@insns));
 393         &pxor   (@X[0],@X[-4&7]);       # "X[0]"^="X[-16]"
 394          eval(shift(@insns));
 395          eval(shift(@insns));
 396
 397         &pxor   (@Tx[0],@X[-2&7]);      # "X[-3]"^"X[-8]"
 398          eval(shift(@insns));
 399          eval(shift(@insns));
 400          eval(shift(@insns));
 401          eval(shift(@insns));
 402
 403         &pxor   (@X[0],@Tx[0]);         # "X[0]"^="X[-3]"^"X[-8]"
 404          eval(shift(@insns));
 405          eval(shift(@insns));
 406           &movdqa       (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer to IALU
 407          eval(shift(@insns));
 408          eval(shift(@insns));
 409
 410         &movdqa (@Tx[2],@X[0]);
 411         &movdqa (@Tx[0],@X[0]);
 412          eval(shift(@insns));
 413          eval(shift(@insns));
 414          eval(shift(@insns));
 415          eval(shift(@insns));
 416
 417         &pslldq (@Tx[2],12);            # "X[0]"<<96, extract one dword
 418         &paddd  (@X[0],@X[0]);
 419          eval(shift(@insns));
 420          eval(shift(@insns));
 421          eval(shift(@insns));
 422          eval(shift(@insns));
 423
 424         &psrld  (@Tx[0],31);
 425          eval(shift(@insns));
 426          eval(shift(@insns));
 427         &movdqa (@Tx[1],@Tx[2]);
 428          eval(shift(@insns));
 429          eval(shift(@insns));
 430
 431         &psrld  (@Tx[2],30);
 432         &por    (@X[0],@Tx[0]);         # "X[0]"<<<=1
 433          eval(shift(@insns));
 434          eval(shift(@insns));
 435          eval(shift(@insns));
 436          eval(shift(@insns));
 437
 438         &pslld  (@Tx[1],2);
 439         &pxor   (@X[0],@Tx[2]);
 440          eval(shift(@insns));
 441          eval(shift(@insns));
 442           &movdqa       (@Tx[2],eval(16*(($Xi)/5))."($K_XX_XX)");       # K_XX_XX
 443          eval(shift(@insns));
 444          eval(shift(@insns));
 445
 446         &pxor   (@X[0],@Tx[1]);         # "X[0]"^=("X[0]">>96)<<<2
 447
 448          foreach (@insns) { eval; }     # remaining instructions [if any]
 449
 450   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 451                 push(@Tx,shift(@Tx));
 452 }
 453
 454 sub Xupdate_ssse3_32_79()
 455 { use integer;
 456   my $body = shift;
 457   my @insns = (&$body,&$body,&$body,&$body);    # 32 to 44 instructions
 458   my ($a,$b,$c,$d,$e);
 459
 460         &movdqa (@Tx[0],@X[-1&7])       if ($Xi==8);
 461          eval(shift(@insns));           # body_20_39
 462         &pxor   (@X[0],@X[-4&7]);       # "X[0]"="X[-32]"^"X[-16]"
 463         &palignr(@Tx[0],@X[-2&7],8);    # compose "X[-6]"
 464          eval(shift(@insns));
 465          eval(shift(@insns));
 466          eval(shift(@insns));           # rol
 467
 468         &pxor   (@X[0],@X[-7&7]);       # "X[0]"^="X[-28]"
 469          eval(shift(@insns));
 470          eval(shift(@insns))    if (@insns[0] !~ /&ro[rl]/);
 471         if ($Xi%5) {
 472           &movdqa       (@Tx[2],@Tx[1]);# "perpetuate" K_XX_XX...
 473         } else {                        # ... or load next one
 474           &movdqa       (@Tx[2],eval(16*($Xi/5))."($K_XX_XX)");
 475         }
 476           &paddd        (@Tx[1],@X[-1&7]);
 477          eval(shift(@insns));           # ror
 478          eval(shift(@insns));
 479
 480         &pxor   (@X[0],@Tx[0]);         # "X[0]"^="X[-6]"
 481          eval(shift(@insns));           # body_20_39
 482          eval(shift(@insns));
 483          eval(shift(@insns));
 484          eval(shift(@insns));           # rol
 485
 486         &movdqa (@Tx[0],@X[0]);
 487           &movdqa       (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer to IALU
 488          eval(shift(@insns));
 489          eval(shift(@insns));
 490          eval(shift(@insns));           # ror
 491          eval(shift(@insns));
 492
 493         &pslld  (@X[0],2);
 494          eval(shift(@insns));           # body_20_39
 495          eval(shift(@insns));
 496         &psrld  (@Tx[0],30);
 497          eval(shift(@insns));
 498          eval(shift(@insns));           # rol
 499          eval(shift(@insns));
 500          eval(shift(@insns));
 501          eval(shift(@insns));           # ror
 502          eval(shift(@insns));
 503
 504         &por    (@X[0],@Tx[0]);         # "X[0]"<<<=2
 505          eval(shift(@insns));           # body_20_39
 506          eval(shift(@insns));
 507           &movdqa       (@Tx[1],@X[0])  if ($Xi<19);
 508          eval(shift(@insns));
 509          eval(shift(@insns));           # rol
 510          eval(shift(@insns));
 511          eval(shift(@insns));
 512          eval(shift(@insns));           # rol
 513          eval(shift(@insns));
 514
 515          foreach (@insns) { eval; }     # remaining instructions
 516
 517   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 518                 push(@Tx,shift(@Tx));
 519 }
 520
 521 sub Xuplast_ssse3_80()
 522 { use integer;
 523   my $body = shift;
 524   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 525   my ($a,$b,$c,$d,$e);
 526
 527          eval(shift(@insns));
 528           &paddd        (@Tx[1],@X[-1&7]);
 529          eval(shift(@insns));
 530          eval(shift(@insns));
 531          eval(shift(@insns));
 532          eval(shift(@insns));
 533
 534           &movdqa       (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer IALU
 535
 536          foreach (@insns) { eval; }             # remaining instructions
 537
 538         &cmp    ($inp,$num);
 539         &je     (".Ldone_ssse3");
 540
 541         unshift(@Tx,pop(@Tx));
 542
 543         &movdqa (@X[2],"64($K_XX_XX)");         # pbswap mask
 544         &movdqa (@Tx[1],"0($K_XX_XX)");         # K_00_19
 545         &movdqu (@X[-4&7],"0($inp)");           # load input
 546         &movdqu (@X[-3&7],"16($inp)");
 547         &movdqu (@X[-2&7],"32($inp)");
 548         &movdqu (@X[-1&7],"48($inp)");
 549         &pshufb (@X[-4&7],@X[2]);               # byte swap
 550         &add    ($inp,64);
 551
 552   $Xi=0;
 553 }
 554
 555 sub Xloop_ssse3()
 556 { use integer;
 557   my $body = shift;
 558   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 559   my ($a,$b,$c,$d,$e);
 560
 561          eval(shift(@insns));
 562          eval(shift(@insns));
 563         &pshufb (@X[($Xi-3)&7],@X[2]);
 564          eval(shift(@insns));
 565          eval(shift(@insns));
 566         &paddd  (@X[($Xi-4)&7],@Tx[1]);
 567          eval(shift(@insns));
 568          eval(shift(@insns));
 569          eval(shift(@insns));
 570          eval(shift(@insns));
 571         &movdqa (eval(16*$Xi)."(%rsp)",@X[($Xi-4)&7]);  # X[]+K xfer to IALU
 572          eval(shift(@insns));
 573          eval(shift(@insns));
 574         &psubd  (@X[($Xi-4)&7],@Tx[1]);
 575
 576         foreach (@insns) { eval; }
 577   $Xi++;
 578 }
 579
 580 sub Xtail_ssse3()
 581 { use integer;
 582   my $body = shift;
 583   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 584   my ($a,$b,$c,$d,$e);
 585
 586         foreach (@insns) { eval; }
 587 }
 588
 589 sub body_00_19 () {
 590         (
 591         '($a,$b,$c,$d,$e)=@V;'.
 592         '&add   ($e,eval(4*($j&15))."(%rsp)");',        # X[]+K xfer
 593         '&xor   ($c,$d);',
 594         '&mov   (@T[1],$a);',   # $b in next round
 595         '&$_rol ($a,5);',
 596         '&and   (@T[0],$c);',   # ($b&($c^$d))
 597         '&xor   ($c,$d);',      # restore $c
 598         '&xor   (@T[0],$d);',
 599         '&add   ($e,$a);',
 600         '&$_ror ($b,$j?7:2);',  # $b>>>2
 601         '&add   ($e,@T[0]);'    .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 602         );
 603 }
 604
 605 sub body_20_39 () {
 606         (
 607         '($a,$b,$c,$d,$e)=@V;'.
 608         '&add   ($e,eval(4*($j++&15))."(%rsp)");',      # X[]+K xfer
 609         '&xor   (@T[0],$d);',   # ($b^$d)
 610         '&mov   (@T[1],$a);',   # $b in next round
 611         '&$_rol ($a,5);',
 612         '&xor   (@T[0],$c);',   # ($b^$d^$c)
 613         '&add   ($e,$a);',
 614         '&$_ror ($b,7);',       # $b>>>2
 615         '&add   ($e,@T[0]);'    .'unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 616         );
 617 }
 618
 619 sub body_40_59 () {
 620         (
 621         '($a,$b,$c,$d,$e)=@V;'.
 622         '&xor   (@T[0],$c);',
 623         '&xor   (@T[1],$d);',
 624         '&add   ($e,eval(4*($j++&15))."(%rsp)");',      # X[]+K xfer
 625         '&and   (@T[0],$T[1]);',
 626         '&$_ror ($b,7);',       # $b>>>2
 627         '&xor   (@T[0],$c);',
 628         '&mov   (@T[1],$a);',   # $b in next round
 629         '&$_rol ($a,5);',
 630         '&add   ($e,@T[0]);',
 631         '&mov   (@T[0],$b);',   # copy of $c in next round
 632         '&add   ($e,$a);'       .'unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 633         );
 634 }
 635 $code.=<<___;
 636 .align  16
 637 .Loop_ssse3:
 638 ___
 639         &Xupdate_ssse3_16_31(\&body_00_19);
 640         &Xupdate_ssse3_16_31(\&body_00_19);
 641         &Xupdate_ssse3_16_31(\&body_00_19);
 642         &Xupdate_ssse3_16_31(\&body_00_19);
 643         &Xupdate_ssse3_32_79(\&body_00_19);
 644         &Xupdate_ssse3_32_79(\&body_20_39);
 645         &Xupdate_ssse3_32_79(\&body_20_39);
 646         &Xupdate_ssse3_32_79(\&body_20_39);
 647         &Xupdate_ssse3_32_79(\&body_20_39);
 648         &Xupdate_ssse3_32_79(\&body_20_39);
 649         &mov    (@T[1],@V[2]);  # copy of $c in next round
 650         &Xupdate_ssse3_32_79(\&body_40_59);
 651         &Xupdate_ssse3_32_79(\&body_40_59);
 652         &Xupdate_ssse3_32_79(\&body_40_59);
 653         &Xupdate_ssse3_32_79(\&body_40_59);
 654         &Xupdate_ssse3_32_79(\&body_40_59);
 655         &Xupdate_ssse3_32_79(\&body_20_39);
 656         &Xuplast_ssse3_80(\&body_20_39);        # can jump to "done"
 657
 658                                 $saved_j=$j; @saved_V=@V;
 659
 660         &Xloop_ssse3(\&body_20_39);
 661         &Xloop_ssse3(\&body_20_39);
 662         &Xloop_ssse3(\&body_20_39);
 663
 664 $code.=<<___;
 665         add     0($ctx),$A                      # update context
 666         add     4($ctx),@T[0]
 667         add     8($ctx),$C
 668         add     12($ctx),$D
 669         mov     $A,0($ctx)
 670         add     16($ctx),$E
 671         mov     @T[0],4($ctx)
 672         mov     @T[0],$B                        # magic seed
 673         mov     $C,8($ctx)
 674         mov     $D,12($ctx)
 675         mov     $E,16($ctx)
 676         jmp     .Loop_ssse3
 677
 678 .align  16
 679 .Ldone_ssse3:
 680 ___
 681                                 $j=$saved_j; @V=@saved_V;
 682
 683         &Xtail_ssse3(\&body_20_39);
 684         &Xtail_ssse3(\&body_20_39);
 685         &Xtail_ssse3(\&body_20_39);
 686
 687 $code.=<<___;
 688         add     0($ctx),$A                      # update context
 689         add     4($ctx),@T[0]
 690         add     8($ctx),$C
 691         mov     $A,0($ctx)
 692         add     12($ctx),$D
 693         mov     @T[0],4($ctx)
 694         add     16($ctx),$E
 695         mov     $C,8($ctx)
 696         mov     $D,12($ctx)
 697         mov     $E,16($ctx)
 698 ___
 699 $code.=<<___ if ($win64);
 700         movaps  64+0(%rsp),%xmm6
 701         movaps  64+16(%rsp),%xmm7
 702         movaps  64+32(%rsp),%xmm8
 703         movaps  64+48(%rsp),%xmm9
 704         movaps  64+64(%rsp),%xmm10
 705 ___
 706 $code.=<<___;
 707         lea     `64+($win64?5*16:0)`(%rsp),%rsi
 708         mov     0(%rsi),%r12
 709         mov     8(%rsi),%rbp
 710         mov     16(%rsi),%rbx
 711         lea     24(%rsi),%rsp
 712 .Lepilogue_ssse3:
 713         ret
 714 .size   sha1_block_data_order_ssse3,.-sha1_block_data_order_ssse3
 715 ___
 716
 717 if ($avx) {
 718 my $Xi=4;
 719 my @X=map("%xmm$_",(4..7,0..3));
 720 my @Tx=map("%xmm$_",(8..10));
 721 my @V=($A,$B,$C,$D,$E)=("%eax","%ebx","%ecx","%edx","%ebp");    # size optimization
 722 my @T=("%esi","%edi");
 723 my $j=0;
 724 my $K_XX_XX="%r11";
 725
 726 my $_rol=sub { &shld(@_[0],@_) };
 727 my $_ror=sub { &shrd(@_[0],@_) };
 728
 729 $code.=<<___;
 730 .type   sha1_block_data_order_avx,\@function,3
 731 .align  16
 732 sha1_block_data_order_avx:
 733 _avx_shortcut:
 734         push    %rbx
 735         push    %rbp
 736         push    %r12
 737         lea     `-64-($win64?5*16:0)`(%rsp),%rsp
 738 ___
 739 $code.=<<___ if ($win64);
 740         movaps  %xmm6,64+0(%rsp)
 741         movaps  %xmm7,64+16(%rsp)
 742         movaps  %xmm8,64+32(%rsp)
 743         movaps  %xmm9,64+48(%rsp)
 744         movaps  %xmm10,64+64(%rsp)
 745 .Lprologue_avx:
 746 ___
 747 $code.=<<___;
 748         mov     %rdi,$ctx       # reassigned argument
 749         mov     %rsi,$inp       # reassigned argument
 750         mov     %rdx,$num       # reassigned argument
 751         vzeroall
 752
 753         shl     \$6,$num
 754         add     $inp,$num
 755         lea     K_XX_XX(%rip),$K_XX_XX
 756
 757         mov     0($ctx),$A              # load context
 758         mov     4($ctx),$B
 759         mov     8($ctx),$C
 760         mov     12($ctx),$D
 761         mov     $B,@T[0]                # magic seed
 762         mov     16($ctx),$E
 763
 764         vmovdqa 64($K_XX_XX),@X[2]      # pbswap mask
 765         vmovdqa 0($K_XX_XX),@Tx[1]      # K_00_19
 766         vmovdqu 0($inp),@X[-4&7]        # load input to %xmm[0-3]
 767         vmovdqu 16($inp),@X[-3&7]
 768         vmovdqu 32($inp),@X[-2&7]
 769         vmovdqu 48($inp),@X[-1&7]
 770         vpshufb @X[2],@X[-4&7],@X[-4&7] # byte swap
 771         add     \$64,$inp
 772         vpshufb @X[2],@X[-3&7],@X[-3&7]
 773         vpshufb @X[2],@X[-2&7],@X[-2&7]
 774         vpshufb @X[2],@X[-1&7],@X[-1&7]
 775         vpaddd  @Tx[1],@X[-4&7],@X[0]   # add K_00_19
 776         vpaddd  @Tx[1],@X[-3&7],@X[1]
 777         vpaddd  @Tx[1],@X[-2&7],@X[2]
 778         vmovdqa @X[0],0(%rsp)           # X[]+K xfer to IALU
 779         vmovdqa @X[1],16(%rsp)
 780         vmovdqa @X[2],32(%rsp)
 781         jmp     .Loop_avx
 782 ___
 783
 784 sub Xupdate_avx_16_31()         # recall that $Xi starts wtih 4
 785 { use integer;
 786   my $body = shift;
 787   my @insns = (&$body,&$body,&$body,&$body);    # 40 instructions
 788   my ($a,$b,$c,$d,$e);
 789
 790          eval(shift(@insns));
 791          eval(shift(@insns));
 792         &vpalignr(@X[0],@X[-3&7],@X[-4&7],8);   # compose "X[-14]" in "X[0]"
 793          eval(shift(@insns));
 794          eval(shift(@insns));
 795
 796           &vpaddd       (@Tx[1],@Tx[1],@X[-1&7]);
 797          eval(shift(@insns));
 798          eval(shift(@insns));
 799         &vpsrldq(@Tx[0],@X[-1&7],4);    # "X[-3]", 3 dwords
 800          eval(shift(@insns));
 801          eval(shift(@insns));
 802         &vpxor  (@X[0],@X[0],@X[-4&7]);         # "X[0]"^="X[-16]"
 803          eval(shift(@insns));
 804          eval(shift(@insns));
 805
 806         &vpxor  (@Tx[0],@Tx[0],@X[-2&7]);       # "X[-3]"^"X[-8]"
 807          eval(shift(@insns));
 808          eval(shift(@insns));
 809          eval(shift(@insns));
 810          eval(shift(@insns));
 811
 812         &vpxor  (@X[0],@X[0],@Tx[0]);           # "X[0]"^="X[-3]"^"X[-8]"
 813          eval(shift(@insns));
 814          eval(shift(@insns));
 815           &vmovdqa      (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer to IALU
 816          eval(shift(@insns));
 817          eval(shift(@insns));
 818
 819         &vpsrld (@Tx[0],@X[0],31);
 820          eval(shift(@insns));
 821          eval(shift(@insns));
 822          eval(shift(@insns));
 823          eval(shift(@insns));
 824
 825         &vpslldq(@Tx[2],@X[0],12);              # "X[0]"<<96, extract one dword
 826         &vpaddd (@X[0],@X[0],@X[0]);
 827          eval(shift(@insns));
 828          eval(shift(@insns));
 829          eval(shift(@insns));
 830          eval(shift(@insns));
 831
 832         &vpsrld (@Tx[1],@Tx[2],30);
 833         &vpor   (@X[0],@X[0],@Tx[0]);           # "X[0]"<<<=1
 834          eval(shift(@insns));
 835          eval(shift(@insns));
 836          eval(shift(@insns));
 837          eval(shift(@insns));
 838
 839         &vpslld (@Tx[2],@Tx[2],2);
 840         &vpxor  (@X[0],@X[0],@Tx[1]);
 841          eval(shift(@insns));
 842          eval(shift(@insns));
 843          eval(shift(@insns));
 844          eval(shift(@insns));
 845
 846         &vpxor  (@X[0],@X[0],@Tx[2]);           # "X[0]"^=("X[0]">>96)<<<2
 847          eval(shift(@insns));
 848          eval(shift(@insns));
 849           &vmovdqa      (@Tx[2],eval(16*(($Xi)/5))."($K_XX_XX)");       # K_XX_XX
 850          eval(shift(@insns));
 851          eval(shift(@insns));
 852
 853
 854          foreach (@insns) { eval; }     # remaining instructions [if any]
 855
 856   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 857                 push(@Tx,shift(@Tx));
 858 }
 859
 860 sub Xupdate_avx_32_79()
 861 { use integer;
 862   my $body = shift;
 863   my @insns = (&$body,&$body,&$body,&$body);    # 32 to 44 instructions
 864   my ($a,$b,$c,$d,$e);
 865
 866         &vpalignr(@Tx[0],@X[-1&7],@X[-2&7],8);  # compose "X[-6]"
 867         &vpxor  (@X[0],@X[0],@X[-4&7]);         # "X[0]"="X[-32]"^"X[-16]"
 868          eval(shift(@insns));           # body_20_39
 869          eval(shift(@insns));
 870          eval(shift(@insns));
 871          eval(shift(@insns));           # rol
 872
 873         &vpxor  (@X[0],@X[0],@X[-7&7]);         # "X[0]"^="X[-28]"
 874          eval(shift(@insns));
 875          eval(shift(@insns))    if (@insns[0] !~ /&ro[rl]/);
 876         if ($Xi%5) {
 877           &vmovdqa      (@Tx[2],@Tx[1]);# "perpetuate" K_XX_XX...
 878         } else {                        # ... or load next one
 879           &vmovdqa      (@Tx[2],eval(16*($Xi/5))."($K_XX_XX)");
 880         }
 881           &vpaddd       (@Tx[1],@Tx[1],@X[-1&7]);
 882          eval(shift(@insns));           # ror
 883          eval(shift(@insns));
 884
 885         &vpxor  (@X[0],@X[0],@Tx[0]);           # "X[0]"^="X[-6]"
 886          eval(shift(@insns));           # body_20_39
 887          eval(shift(@insns));
 888          eval(shift(@insns));
 889          eval(shift(@insns));           # rol
 890
 891         &vpsrld (@Tx[0],@X[0],30);
 892           &vmovdqa      (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer to IALU
 893          eval(shift(@insns));
 894          eval(shift(@insns));
 895          eval(shift(@insns));           # ror
 896          eval(shift(@insns));
 897
 898         &vpslld (@X[0],@X[0],2);
 899          eval(shift(@insns));           # body_20_39
 900          eval(shift(@insns));
 901          eval(shift(@insns));
 902          eval(shift(@insns));           # rol
 903          eval(shift(@insns));
 904          eval(shift(@insns));
 905          eval(shift(@insns));           # ror
 906          eval(shift(@insns));
 907
 908         &vpor   (@X[0],@X[0],@Tx[0]);           # "X[0]"<<<=2
 909          eval(shift(@insns));           # body_20_39
 910          eval(shift(@insns));
 911           &vmovdqa      (@Tx[1],@X[0])  if ($Xi<19);
 912          eval(shift(@insns));
 913          eval(shift(@insns));           # rol
 914          eval(shift(@insns));
 915          eval(shift(@insns));
 916          eval(shift(@insns));           # rol
 917          eval(shift(@insns));
 918
 919          foreach (@insns) { eval; }     # remaining instructions
 920
 921   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 922                 push(@Tx,shift(@Tx));
 923 }
 924
 925 sub Xuplast_avx_80()
 926 { use integer;
 927   my $body = shift;
 928   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 929   my ($a,$b,$c,$d,$e);
 930
 931          eval(shift(@insns));
 932           &vpaddd       (@Tx[1],@Tx[1],@X[-1&7]);
 933          eval(shift(@insns));
 934          eval(shift(@insns));
 935          eval(shift(@insns));
 936          eval(shift(@insns));
 937
 938           &movdqa       (eval(16*(($Xi-1)&3))."(%rsp)",@Tx[1]); # X[]+K xfer IALU
 939
 940          foreach (@insns) { eval; }             # remaining instructions
 941
 942         &cmp    ($inp,$num);
 943         &je     (".Ldone_avx");
 944
 945         unshift(@Tx,pop(@Tx));
 946
 947         &vmovdqa(@X[2],"64($K_XX_XX)");         # pbswap mask
 948         &vmovdqa(@Tx[1],"0($K_XX_XX)");         # K_00_19
 949         &vmovdqu(@X[-4&7],"0($inp)");           # load input
 950         &vmovdqu(@X[-3&7],"16($inp)");
 951         &vmovdqu(@X[-2&7],"32($inp)");
 952         &vmovdqu(@X[-1&7],"48($inp)");
 953         &vpshufb(@X[-4&7],@X[-4&7],@X[2]);      # byte swap
 954         &add    ($inp,64);
 955
 956   $Xi=0;
 957 }
 958
 959 sub Xloop_avx()
 960 { use integer;
 961   my $body = shift;
 962   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 963   my ($a,$b,$c,$d,$e);
 964
 965          eval(shift(@insns));
 966          eval(shift(@insns));
 967         &vpshufb(@X[($Xi-3)&7],@X[($Xi-3)&7],@X[2]);
 968          eval(shift(@insns));
 969          eval(shift(@insns));
 970         &vpaddd (@X[$Xi&7],@X[($Xi-4)&7],@Tx[1]);
 971          eval(shift(@insns));
 972          eval(shift(@insns));
 973          eval(shift(@insns));
 974          eval(shift(@insns));
 975         &vmovdqa(eval(16*$Xi)."(%rsp)",@X[$Xi&7]);      # X[]+K xfer to IALU
 976          eval(shift(@insns));
 977          eval(shift(@insns));
 978
 979         foreach (@insns) { eval; }
 980   $Xi++;
 981 }
 982
 983 sub Xtail_avx()
 984 { use integer;
 985   my $body = shift;
 986   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 987   my ($a,$b,$c,$d,$e);
 988
 989         foreach (@insns) { eval; }
 990 }
 991
 992 $code.=<<___;
 993 .align  16
 994 .Loop_avx:
 995 ___
 996         &Xupdate_avx_16_31(\&body_00_19);
 997         &Xupdate_avx_16_31(\&body_00_19);
 998         &Xupdate_avx_16_31(\&body_00_19);
 999         &Xupdate_avx_16_31(\&body_00_19);
1000         &Xupdate_avx_32_79(\&body_00_19);
1001         &Xupdate_avx_32_79(\&body_20_39);
1002         &Xupdate_avx_32_79(\&body_20_39);
1003         &Xupdate_avx_32_79(\&body_20_39);
1004         &Xupdate_avx_32_79(\&body_20_39);
1005         &Xupdate_avx_32_79(\&body_20_39);
1006         &mov    (@T[1],@V[2]);  # copy of $c in next round
1007         &Xupdate_avx_32_79(\&body_40_59);
1008         &Xupdate_avx_32_79(\&body_40_59);
1009         &Xupdate_avx_32_79(\&body_40_59);
1010         &Xupdate_avx_32_79(\&body_40_59);
1011         &Xupdate_avx_32_79(\&body_40_59);
1012         &Xupdate_avx_32_79(\&body_20_39);
1013         &Xuplast_avx_80(\&body_20_39);  # can jump to "done"
1014
1015                                 $saved_j=$j; @saved_V=@V;
1016
1017         &Xloop_avx(\&body_20_39);
1018         &Xloop_avx(\&body_20_39);
1019         &Xloop_avx(\&body_20_39);
1020
1021 $code.=<<___;
1022         add     0($ctx),$A                      # update context
1023         add     4($ctx),@T[0]
1024         add     8($ctx),$C
1025         add     12($ctx),$D
1026         mov     $A,0($ctx)
1027         add     16($ctx),$E
1028         mov     @T[0],4($ctx)
1029         mov     @T[0],$B                        # magic seed
1030         mov     $C,8($ctx)
1031         mov     $D,12($ctx)
1032         mov     $E,16($ctx)
1033         jmp     .Loop_avx
1034
1035 .align  16
1036 .Ldone_avx:
1037 ___
1038                                 $j=$saved_j; @V=@saved_V;
1039
1040         &Xtail_avx(\&body_20_39);
1041         &Xtail_avx(\&body_20_39);
1042         &Xtail_avx(\&body_20_39);
1043
1044 $code.=<<___;
1045         vzeroall
1046
1047         add     0($ctx),$A                      # update context
1048         add     4($ctx),@T[0]
1049         add     8($ctx),$C
1050         mov     $A,0($ctx)
1051         add     12($ctx),$D
1052         mov     @T[0],4($ctx)
1053         add     16($ctx),$E
1054         mov     $C,8($ctx)
1055         mov     $D,12($ctx)
1056         mov     $E,16($ctx)
1057 ___
1058 $code.=<<___ if ($win64);
1059         movaps  64+0(%rsp),%xmm6
1060         movaps  64+16(%rsp),%xmm7
1061         movaps  64+32(%rsp),%xmm8
1062         movaps  64+48(%rsp),%xmm9
1063         movaps  64+64(%rsp),%xmm10
1064 ___
1065 $code.=<<___;
1066         lea     `64+($win64?5*16:0)`(%rsp),%rsi
1067         mov     0(%rsi),%r12
1068         mov     8(%rsi),%rbp
1069         mov     16(%rsi),%rbx
1070         lea     24(%rsi),%rsp
1071 .Lepilogue_avx:
1072         ret
1073 .size   sha1_block_data_order_avx,.-sha1_block_data_order_avx
1074 ___
1075 }
1076 $code.=<<___;
1077 .align  64
1078 K_XX_XX:
1079 .long   0x5a827999,0x5a827999,0x5a827999,0x5a827999     # K_00_19
1080 .long   0x6ed9eba1,0x6ed9eba1,0x6ed9eba1,0x6ed9eba1     # K_20_39
1081 .long   0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc     # K_40_59
1082 .long   0xca62c1d6,0xca62c1d6,0xca62c1d6,0xca62c1d6     # K_60_79
1083 .long   0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f     # pbswap mask
1084 ___
1085 }}}
1086 $code.=<<___;
1087 .asciz  "SHA1 block transform for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
1088 .align  64
1089 ___
1090
1091 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
1092 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
1093 if ($win64) {
1094 $rec="%rcx";
1095 $frame="%rdx";
1096 $context="%r8";
1097 $disp="%r9";
1098
1099 $code.=<<___;
1100 .extern __imp_RtlVirtualUnwind
1101 .type   se_handler,\@abi-omnipotent
1102 .align  16
1103 se_handler:
1104         push    %rsi
1105         push    %rdi
1106         push    %rbx
1107         push    %rbp
1108         push    %r12
1109         push    %r13
1110         push    %r14
1111         push    %r15
1112         pushfq
1113         sub     \$64,%rsp
1114
1115         mov     120($context),%rax      # pull context->Rax
1116         mov     248($context),%rbx      # pull context->Rip
1117
1118         lea     .Lprologue(%rip),%r10
1119         cmp     %r10,%rbx               # context->Rip<.Lprologue
1120         jb      .Lcommon_seh_tail
1121
1122         mov     152($context),%rax      # pull context->Rsp
1123
1124         lea     .Lepilogue(%rip),%r10
1125         cmp     %r10,%rbx               # context->Rip>=.Lepilogue
1126         jae     .Lcommon_seh_tail
1127
1128         mov     `16*4`(%rax),%rax       # pull saved stack pointer
1129         lea     32(%rax),%rax
1130
1131         mov     -8(%rax),%rbx
1132         mov     -16(%rax),%rbp
1133         mov     -24(%rax),%r12
1134         mov     -32(%rax),%r13
1135         mov     %rbx,144($context)      # restore context->Rbx
1136         mov     %rbp,160($context)      # restore context->Rbp
1137         mov     %r12,216($context)      # restore context->R12
1138         mov     %r13,224($context)      # restore context->R13
1139
1140         jmp     .Lcommon_seh_tail
1141 .size   se_handler,.-se_handler
1142
1143 .type   ssse3_handler,\@abi-omnipotent
1144 .align  16
1145 ssse3_handler:
1146         push    %rsi
1147         push    %rdi
1148         push    %rbx
1149         push    %rbp
1150         push    %r12
1151         push    %r13
1152         push    %r14
1153         push    %r15
1154         pushfq
1155         sub     \$64,%rsp
1156
1157         mov     120($context),%rax      # pull context->Rax
1158         mov     248($context),%rbx      # pull context->Rip
1159
1160         mov     8($disp),%rsi           # disp->ImageBase
1161         mov     56($disp),%r11          # disp->HandlerData
1162
1163         mov     0(%r11),%r10d           # HandlerData[0]
1164         lea     (%rsi,%r10),%r10        # prologue label
1165         cmp     %r10,%rbx               # context->Rip<prologue label
1166         jb      .Lcommon_seh_tail
1167
1168         mov     152($context),%rax      # pull context->Rsp
1169
1170         mov     4(%r11),%r10d           # HandlerData[1]
1171         lea     (%rsi,%r10),%r10        # epilogue label
1172         cmp     %r10,%rbx               # context->Rip>=epilogue label
1173         jae     .Lcommon_seh_tail
1174
1175         lea     64(%rax),%rsi
1176         lea     512($context),%rdi      # &context.Xmm6
1177         mov     \$10,%ecx
1178         .long   0xa548f3fc              # cld; rep movsq
1179         lea     `24+64+5*16`(%rax),%rax # adjust stack pointer
1180
1181         mov     -8(%rax),%rbx
1182         mov     -16(%rax),%rbp
1183         mov     -24(%rax),%r12
1184         mov     %rbx,144($context)      # restore context->Rbx
1185         mov     %rbp,160($context)      # restore context->Rbp
1186         mov     %r12,216($context)      # restore cotnext->R12
1187
1188 .Lcommon_seh_tail:
1189         mov     8(%rax),%rdi
1190         mov     16(%rax),%rsi
1191         mov     %rax,152($context)      # restore context->Rsp
1192         mov     %rsi,168($context)      # restore context->Rsi
1193         mov     %rdi,176($context)      # restore context->Rdi
1194
1195         mov     40($disp),%rdi          # disp->ContextRecord
1196         mov     $context,%rsi           # context
1197         mov     \$154,%ecx              # sizeof(CONTEXT)
1198         .long   0xa548f3fc              # cld; rep movsq
1199
1200         mov     $disp,%rsi
1201         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
1202         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
1203         mov     0(%rsi),%r8             # arg3, disp->ControlPc
1204         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
1205         mov     40(%rsi),%r10           # disp->ContextRecord
1206         lea     56(%rsi),%r11           # &disp->HandlerData
1207         lea     24(%rsi),%r12           # &disp->EstablisherFrame
1208         mov     %r10,32(%rsp)           # arg5
1209         mov     %r11,40(%rsp)           # arg6
1210         mov     %r12,48(%rsp)           # arg7
1211         mov     %rcx,56(%rsp)           # arg8, (NULL)
1212         call    *__imp_RtlVirtualUnwind(%rip)
1213
1214         mov     \$1,%eax                # ExceptionContinueSearch
1215         add     \$64,%rsp
1216         popfq
1217         pop     %r15
1218         pop     %r14
1219         pop     %r13
1220         pop     %r12
1221         pop     %rbp
1222         pop     %rbx
1223         pop     %rdi
1224         pop     %rsi
1225         ret
1226 .size   ssse3_handler,.-ssse3_handler
1227
1228 .section        .pdata
1229 .align  4
1230         .rva    .LSEH_begin_sha1_block_data_order
1231         .rva    .LSEH_end_sha1_block_data_order
1232         .rva    .LSEH_info_sha1_block_data_order
1233         .rva    .LSEH_begin_sha1_block_data_order_ssse3
1234         .rva    .LSEH_end_sha1_block_data_order_ssse3
1235         .rva    .LSEH_info_sha1_block_data_order_ssse3
1236 ___
1237 $code.=<<___ if ($avx);
1238         .rva    .LSEH_begin_sha1_block_data_order_avx
1239         .rva    .LSEH_end_sha1_block_data_order_avx
1240         .rva    .LSEH_info_sha1_block_data_order_avx
1241 ___
1242 $code.=<<___;
1243 .section        .xdata
1244 .align  8
1245 .LSEH_info_sha1_block_data_order:
1246         .byte   9,0,0,0
1247         .rva    se_handler
1248 .LSEH_info_sha1_block_data_order_ssse3:
1249         .byte   9,0,0,0
1250         .rva    ssse3_handler
1251         .rva    .Lprologue_ssse3,.Lepilogue_ssse3       # HandlerData[]
1252 ___
1253 $code.=<<___ if ($avx);
1254 .LSEH_info_sha1_block_data_order_avx:
1255         .byte   9,0,0,0
1256         .rva    ssse3_handler
1257         .rva    .Lprologue_avx,.Lepilogue_avx           # HandlerData[]
1258 ___
1259 }
1260
1261 ####################################################################
1262
1263 $code =~ s/\`([^\`]*)\`/eval $1/gem;
1264 print $code;
1265 close STDOUT;