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