x86_64 assembly pack: fill some blanks in Ryzen results.
[openssl.git] / crypto / sha / asm / sha512-x86_64.pl
1 #! /usr/bin/env perl
2 # Copyright 2005-2016 The OpenSSL Project Authors. All Rights Reserved.
3 #
4 # Licensed under the OpenSSL license (the "License").  You may not use
5 # this file except in compliance with the License.  You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
8
9 #
10 # ====================================================================
11 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
12 # project. Rights for redistribution and usage in source and binary
13 # forms are granted according to the OpenSSL license.
14 # ====================================================================
15 #
16 # sha256/512_block procedure for x86_64.
17 #
18 # 40% improvement over compiler-generated code on Opteron. On EM64T
19 # sha256 was observed to run >80% faster and sha512 - >40%. No magical
20 # tricks, just straight implementation... I really wonder why gcc
21 # [being armed with inline assembler] fails to generate as fast code.
22 # The only thing which is cool about this module is that it's very
23 # same instruction sequence used for both SHA-256 and SHA-512. In
24 # former case the instructions operate on 32-bit operands, while in
25 # latter - on 64-bit ones. All I had to do is to get one flavor right,
26 # the other one passed the test right away:-)
27 #
28 # sha256_block runs in ~1005 cycles on Opteron, which gives you
29 # asymptotic performance of 64*1000/1005=63.7MBps times CPU clock
30 # frequency in GHz. sha512_block runs in ~1275 cycles, which results
31 # in 128*1000/1275=100MBps per GHz. Is there room for improvement?
32 # Well, if you compare it to IA-64 implementation, which maintains
33 # X[16] in register bank[!], tends to 4 instructions per CPU clock
34 # cycle and runs in 1003 cycles, 1275 is very good result for 3-way
35 # issue Opteron pipeline and X[16] maintained in memory. So that *if*
36 # there is a way to improve it, *then* the only way would be to try to
37 # offload X[16] updates to SSE unit, but that would require "deeper"
38 # loop unroll, which in turn would naturally cause size blow-up, not
39 # to mention increased complexity! And once again, only *if* it's
40 # actually possible to noticeably improve overall ILP, instruction
41 # level parallelism, on a given CPU implementation in this case.
42 #
43 # Special note on Intel EM64T. While Opteron CPU exhibits perfect
44 # performance ratio of 1.5 between 64- and 32-bit flavors [see above],
45 # [currently available] EM64T CPUs apparently are far from it. On the
46 # contrary, 64-bit version, sha512_block, is ~30% *slower* than 32-bit
47 # sha256_block:-( This is presumably because 64-bit shifts/rotates
48 # apparently are not atomic instructions, but implemented in microcode.
49 #
50 # May 2012.
51 #
52 # Optimization including one of Pavel Semjanov's ideas, alternative
53 # Maj, resulted in >=5% improvement on most CPUs, +20% SHA256 and
54 # unfortunately -2% SHA512 on P4 [which nobody should care about
55 # that much].
56 #
57 # June 2012.
58 #
59 # Add SIMD code paths, see below for improvement coefficients. SSSE3
60 # code path was not attempted for SHA512, because improvement is not
61 # estimated to be high enough, noticeably less than 9%, to justify
62 # the effort, not on pre-AVX processors. [Obviously with exclusion
63 # for VIA Nano, but it has SHA512 instruction that is faster and
64 # should be used instead.] For reference, corresponding estimated
65 # upper limit for improvement for SSSE3 SHA256 is 28%. The fact that
66 # higher coefficients are observed on VIA Nano and Bulldozer has more
67 # to do with specifics of their architecture [which is topic for
68 # separate discussion].
69 #
70 # November 2012.
71 #
72 # Add AVX2 code path. Two consecutive input blocks are loaded to
73 # 256-bit %ymm registers, with data from first block to least
74 # significant 128-bit halves and data from second to most significant.
75 # The data is then processed with same SIMD instruction sequence as
76 # for AVX, but with %ymm as operands. Side effect is increased stack
77 # frame, 448 additional bytes in SHA256 and 1152 in SHA512, and 1.2KB
78 # code size increase.
79 #
80 # March 2014.
81 #
82 # Add support for Intel SHA Extensions.
83
84 ######################################################################
85 # Current performance in cycles per processed byte (less is better):
86 #
87 #               SHA256  SSSE3       AVX/XOP(*)      SHA512  AVX/XOP(*)
88 #
89 # AMD K8        14.9    -           -               9.57    -
90 # P4            17.3    -           -               30.8    -
91 # Core 2        15.6    13.8(+13%)  -               9.97    -
92 # Westmere      14.8    12.3(+19%)  -               9.58    -
93 # Sandy Bridge  17.4    14.2(+23%)  11.6(+50%(**))  11.2    8.10(+38%(**))
94 # Ivy Bridge    12.6    10.5(+20%)  10.3(+22%)      8.17    7.22(+13%)
95 # Haswell       12.2    9.28(+31%)  7.80(+56%)      7.66    5.40(+42%)
96 # Skylake       11.4    9.03(+26%)  7.70(+48%)      7.25    5.20(+40%)
97 # Bulldozer     21.1    13.6(+54%)  13.6(+54%(***)) 13.5    8.58(+57%)
98 # Ryzen         11.0    9.02(+22%)  2.05(+440%)     7.05    5.67(+20%)
99 # VIA Nano      23.0    16.5(+39%)  -               14.7    -
100 # Atom          23.0    18.9(+22%)  -               14.7    -
101 # Silvermont    27.4    20.6(+33%)  -               17.5    -
102 # Goldmont      18.9    14.3(+32%)  4.16(+350%)     12.0    -
103 #
104 # (*)   whichever best applicable, including SHAEXT;
105 # (**)  switch from ror to shrd stands for fair share of improvement;
106 # (***) execution time is fully determined by remaining integer-only
107 #       part, body_00_15; reducing the amount of SIMD instructions
108 #       below certain limit makes no difference/sense; to conserve
109 #       space SHA256 XOP code path is therefore omitted;
110
111 $flavour = shift;
112 $output  = shift;
113 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
114
115 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
116
117 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
118 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
119 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
120 die "can't locate x86_64-xlate.pl";
121
122 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
123                 =~ /GNU assembler version ([2-9]\.[0-9]+)/) {
124         $avx = ($1>=2.19) + ($1>=2.22);
125 }
126
127 if (!$avx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
128            `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
129         $avx = ($1>=2.09) + ($1>=2.10);
130 }
131
132 if (!$avx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
133            `ml64 2>&1` =~ /Version ([0-9]+)\./) {
134         $avx = ($1>=10) + ($1>=11);
135 }
136
137 if (!$avx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|.*based on LLVM) ([3-9]\.[0-9]+)/) {
138         $avx = ($2>=3.0) + ($2>3.0);
139 }
140
141 $shaext=1;      ### set to zero if compiling for 1.0.1
142 $avx=1          if (!$shaext && $avx);
143
144 open OUT,"| \"$^X\" \"$xlate\" $flavour \"$output\"";
145 *STDOUT=*OUT;
146
147 if ($output =~ /512/) {
148         $func="sha512_block_data_order";
149         $TABLE="K512";
150         $SZ=8;
151         @ROT=($A,$B,$C,$D,$E,$F,$G,$H)=("%rax","%rbx","%rcx","%rdx",
152                                         "%r8", "%r9", "%r10","%r11");
153         ($T1,$a0,$a1,$a2,$a3)=("%r12","%r13","%r14","%r15","%rdi");
154         @Sigma0=(28,34,39);
155         @Sigma1=(14,18,41);
156         @sigma0=(1,  8, 7);
157         @sigma1=(19,61, 6);
158         $rounds=80;
159 } else {
160         $func="sha256_block_data_order";
161         $TABLE="K256";
162         $SZ=4;
163         @ROT=($A,$B,$C,$D,$E,$F,$G,$H)=("%eax","%ebx","%ecx","%edx",
164                                         "%r8d","%r9d","%r10d","%r11d");
165         ($T1,$a0,$a1,$a2,$a3)=("%r12d","%r13d","%r14d","%r15d","%edi");
166         @Sigma0=( 2,13,22);
167         @Sigma1=( 6,11,25);
168         @sigma0=( 7,18, 3);
169         @sigma1=(17,19,10);
170         $rounds=64;
171 }
172
173 $ctx="%rdi";    # 1st arg, zapped by $a3
174 $inp="%rsi";    # 2nd arg
175 $Tbl="%rbp";
176
177 $_ctx="16*$SZ+0*8(%rsp)";
178 $_inp="16*$SZ+1*8(%rsp)";
179 $_end="16*$SZ+2*8(%rsp)";
180 $_rsp="`16*$SZ+3*8`(%rsp)";
181 $framesz="16*$SZ+4*8";
182
183
184 sub ROUND_00_15()
185 { my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
186   my $STRIDE=$SZ;
187      $STRIDE += 16 if ($i%(16/$SZ)==(16/$SZ-1));
188
189 $code.=<<___;
190         ror     \$`$Sigma1[2]-$Sigma1[1]`,$a0
191         mov     $f,$a2
192
193         xor     $e,$a0
194         ror     \$`$Sigma0[2]-$Sigma0[1]`,$a1
195         xor     $g,$a2                  # f^g
196
197         mov     $T1,`$SZ*($i&0xf)`(%rsp)
198         xor     $a,$a1
199         and     $e,$a2                  # (f^g)&e
200
201         ror     \$`$Sigma1[1]-$Sigma1[0]`,$a0
202         add     $h,$T1                  # T1+=h
203         xor     $g,$a2                  # Ch(e,f,g)=((f^g)&e)^g
204
205         ror     \$`$Sigma0[1]-$Sigma0[0]`,$a1
206         xor     $e,$a0
207         add     $a2,$T1                 # T1+=Ch(e,f,g)
208
209         mov     $a,$a2
210         add     ($Tbl),$T1              # T1+=K[round]
211         xor     $a,$a1
212
213         xor     $b,$a2                  # a^b, b^c in next round
214         ror     \$$Sigma1[0],$a0        # Sigma1(e)
215         mov     $b,$h
216
217         and     $a2,$a3
218         ror     \$$Sigma0[0],$a1        # Sigma0(a)
219         add     $a0,$T1                 # T1+=Sigma1(e)
220
221         xor     $a3,$h                  # h=Maj(a,b,c)=Ch(a^b,c,b)
222         add     $T1,$d                  # d+=T1
223         add     $T1,$h                  # h+=T1
224
225         lea     $STRIDE($Tbl),$Tbl      # round++
226 ___
227 $code.=<<___ if ($i<15);
228         add     $a1,$h                  # h+=Sigma0(a)
229 ___
230         ($a2,$a3) = ($a3,$a2);
231 }
232
233 sub ROUND_16_XX()
234 { my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
235
236 $code.=<<___;
237         mov     `$SZ*(($i+1)&0xf)`(%rsp),$a0
238         mov     `$SZ*(($i+14)&0xf)`(%rsp),$a2
239
240         mov     $a0,$T1
241         ror     \$`$sigma0[1]-$sigma0[0]`,$a0
242         add     $a1,$a                  # modulo-scheduled h+=Sigma0(a)
243         mov     $a2,$a1
244         ror     \$`$sigma1[1]-$sigma1[0]`,$a2
245
246         xor     $T1,$a0
247         shr     \$$sigma0[2],$T1
248         ror     \$$sigma0[0],$a0
249         xor     $a1,$a2
250         shr     \$$sigma1[2],$a1
251
252         ror     \$$sigma1[0],$a2
253         xor     $a0,$T1                 # sigma0(X[(i+1)&0xf])
254         xor     $a1,$a2                 # sigma1(X[(i+14)&0xf])
255         add     `$SZ*(($i+9)&0xf)`(%rsp),$T1
256
257         add     `$SZ*($i&0xf)`(%rsp),$T1
258         mov     $e,$a0
259         add     $a2,$T1
260         mov     $a,$a1
261 ___
262         &ROUND_00_15(@_);
263 }
264
265 $code=<<___;
266 .text
267
268 .extern OPENSSL_ia32cap_P
269 .globl  $func
270 .type   $func,\@function,3
271 .align  16
272 $func:
273 .cfi_startproc
274 ___
275 $code.=<<___ if ($SZ==4 || $avx);
276         lea     OPENSSL_ia32cap_P(%rip),%r11
277         mov     0(%r11),%r9d
278         mov     4(%r11),%r10d
279         mov     8(%r11),%r11d
280 ___
281 $code.=<<___ if ($SZ==4 && $shaext);
282         test    \$`1<<29`,%r11d         # check for SHA
283         jnz     _shaext_shortcut
284 ___
285 $code.=<<___ if ($avx && $SZ==8);
286         test    \$`1<<11`,%r10d         # check for XOP
287         jnz     .Lxop_shortcut
288 ___
289 $code.=<<___ if ($avx>1);
290         and     \$`1<<8|1<<5|1<<3`,%r11d        # check for BMI2+AVX2+BMI1
291         cmp     \$`1<<8|1<<5|1<<3`,%r11d
292         je      .Lavx2_shortcut
293 ___
294 $code.=<<___ if ($avx);
295         and     \$`1<<30`,%r9d          # mask "Intel CPU" bit
296         and     \$`1<<28|1<<9`,%r10d    # mask AVX and SSSE3 bits
297         or      %r9d,%r10d
298         cmp     \$`1<<28|1<<9|1<<30`,%r10d
299         je      .Lavx_shortcut
300 ___
301 $code.=<<___ if ($SZ==4);
302         test    \$`1<<9`,%r10d
303         jnz     .Lssse3_shortcut
304 ___
305 $code.=<<___;
306         mov     %rsp,%rax               # copy %rsp
307 .cfi_def_cfa_register   %rax
308         push    %rbx
309 .cfi_push       %rbx
310         push    %rbp
311 .cfi_push       %rbp
312         push    %r12
313 .cfi_push       %r12
314         push    %r13
315 .cfi_push       %r13
316         push    %r14
317 .cfi_push       %r14
318         push    %r15
319 .cfi_push       %r15
320         shl     \$4,%rdx                # num*16
321         sub     \$$framesz,%rsp
322         lea     ($inp,%rdx,$SZ),%rdx    # inp+num*16*$SZ
323         and     \$-64,%rsp              # align stack frame
324         mov     $ctx,$_ctx              # save ctx, 1st arg
325         mov     $inp,$_inp              # save inp, 2nd arh
326         mov     %rdx,$_end              # save end pointer, "3rd" arg
327         mov     %rax,$_rsp              # save copy of %rsp
328 .cfi_cfa_expression     $_rsp,deref,+8
329 .Lprologue:
330
331         mov     $SZ*0($ctx),$A
332         mov     $SZ*1($ctx),$B
333         mov     $SZ*2($ctx),$C
334         mov     $SZ*3($ctx),$D
335         mov     $SZ*4($ctx),$E
336         mov     $SZ*5($ctx),$F
337         mov     $SZ*6($ctx),$G
338         mov     $SZ*7($ctx),$H
339         jmp     .Lloop
340
341 .align  16
342 .Lloop:
343         mov     $B,$a3
344         lea     $TABLE(%rip),$Tbl
345         xor     $C,$a3                  # magic
346 ___
347         for($i=0;$i<16;$i++) {
348                 $code.="        mov     $SZ*$i($inp),$T1\n";
349                 $code.="        mov     @ROT[4],$a0\n";
350                 $code.="        mov     @ROT[0],$a1\n";
351                 $code.="        bswap   $T1\n";
352                 &ROUND_00_15($i,@ROT);
353                 unshift(@ROT,pop(@ROT));
354         }
355 $code.=<<___;
356         jmp     .Lrounds_16_xx
357 .align  16
358 .Lrounds_16_xx:
359 ___
360         for(;$i<32;$i++) {
361                 &ROUND_16_XX($i,@ROT);
362                 unshift(@ROT,pop(@ROT));
363         }
364
365 $code.=<<___;
366         cmpb    \$0,`$SZ-1`($Tbl)
367         jnz     .Lrounds_16_xx
368
369         mov     $_ctx,$ctx
370         add     $a1,$A                  # modulo-scheduled h+=Sigma0(a)
371         lea     16*$SZ($inp),$inp
372
373         add     $SZ*0($ctx),$A
374         add     $SZ*1($ctx),$B
375         add     $SZ*2($ctx),$C
376         add     $SZ*3($ctx),$D
377         add     $SZ*4($ctx),$E
378         add     $SZ*5($ctx),$F
379         add     $SZ*6($ctx),$G
380         add     $SZ*7($ctx),$H
381
382         cmp     $_end,$inp
383
384         mov     $A,$SZ*0($ctx)
385         mov     $B,$SZ*1($ctx)
386         mov     $C,$SZ*2($ctx)
387         mov     $D,$SZ*3($ctx)
388         mov     $E,$SZ*4($ctx)
389         mov     $F,$SZ*5($ctx)
390         mov     $G,$SZ*6($ctx)
391         mov     $H,$SZ*7($ctx)
392         jb      .Lloop
393
394         mov     $_rsp,%rsi
395 .cfi_def_cfa    %rsi,8
396         mov     -48(%rsi),%r15
397 .cfi_restore    %r15
398         mov     -40(%rsi),%r14
399 .cfi_restore    %r14
400         mov     -32(%rsi),%r13
401 .cfi_restore    %r13
402         mov     -24(%rsi),%r12
403 .cfi_restore    %r12
404         mov     -16(%rsi),%rbp
405 .cfi_restore    %rbp
406         mov     -8(%rsi),%rbx
407 .cfi_restore    %rbx
408         lea     (%rsi),%rsp
409 .cfi_def_cfa_register   %rsp
410 .Lepilogue:
411         ret
412 .cfi_endproc
413 .size   $func,.-$func
414 ___
415
416 if ($SZ==4) {
417 $code.=<<___;
418 .align  64
419 .type   $TABLE,\@object
420 $TABLE:
421         .long   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
422         .long   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
423         .long   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
424         .long   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
425         .long   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
426         .long   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
427         .long   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
428         .long   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
429         .long   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
430         .long   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
431         .long   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
432         .long   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
433         .long   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
434         .long   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
435         .long   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
436         .long   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
437         .long   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
438         .long   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
439         .long   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
440         .long   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
441         .long   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
442         .long   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
443         .long   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
444         .long   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
445         .long   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
446         .long   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
447         .long   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
448         .long   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
449         .long   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
450         .long   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
451         .long   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
452         .long   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
453
454         .long   0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
455         .long   0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
456         .long   0x03020100,0x0b0a0908,0xffffffff,0xffffffff
457         .long   0x03020100,0x0b0a0908,0xffffffff,0xffffffff
458         .long   0xffffffff,0xffffffff,0x03020100,0x0b0a0908
459         .long   0xffffffff,0xffffffff,0x03020100,0x0b0a0908
460         .asciz  "SHA256 block transform for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
461 ___
462 } else {
463 $code.=<<___;
464 .align  64
465 .type   $TABLE,\@object
466 $TABLE:
467         .quad   0x428a2f98d728ae22,0x7137449123ef65cd
468         .quad   0x428a2f98d728ae22,0x7137449123ef65cd
469         .quad   0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
470         .quad   0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
471         .quad   0x3956c25bf348b538,0x59f111f1b605d019
472         .quad   0x3956c25bf348b538,0x59f111f1b605d019
473         .quad   0x923f82a4af194f9b,0xab1c5ed5da6d8118
474         .quad   0x923f82a4af194f9b,0xab1c5ed5da6d8118
475         .quad   0xd807aa98a3030242,0x12835b0145706fbe
476         .quad   0xd807aa98a3030242,0x12835b0145706fbe
477         .quad   0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
478         .quad   0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
479         .quad   0x72be5d74f27b896f,0x80deb1fe3b1696b1
480         .quad   0x72be5d74f27b896f,0x80deb1fe3b1696b1
481         .quad   0x9bdc06a725c71235,0xc19bf174cf692694
482         .quad   0x9bdc06a725c71235,0xc19bf174cf692694
483         .quad   0xe49b69c19ef14ad2,0xefbe4786384f25e3
484         .quad   0xe49b69c19ef14ad2,0xefbe4786384f25e3
485         .quad   0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
486         .quad   0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
487         .quad   0x2de92c6f592b0275,0x4a7484aa6ea6e483
488         .quad   0x2de92c6f592b0275,0x4a7484aa6ea6e483
489         .quad   0x5cb0a9dcbd41fbd4,0x76f988da831153b5
490         .quad   0x5cb0a9dcbd41fbd4,0x76f988da831153b5
491         .quad   0x983e5152ee66dfab,0xa831c66d2db43210
492         .quad   0x983e5152ee66dfab,0xa831c66d2db43210
493         .quad   0xb00327c898fb213f,0xbf597fc7beef0ee4
494         .quad   0xb00327c898fb213f,0xbf597fc7beef0ee4
495         .quad   0xc6e00bf33da88fc2,0xd5a79147930aa725
496         .quad   0xc6e00bf33da88fc2,0xd5a79147930aa725
497         .quad   0x06ca6351e003826f,0x142929670a0e6e70
498         .quad   0x06ca6351e003826f,0x142929670a0e6e70
499         .quad   0x27b70a8546d22ffc,0x2e1b21385c26c926
500         .quad   0x27b70a8546d22ffc,0x2e1b21385c26c926
501         .quad   0x4d2c6dfc5ac42aed,0x53380d139d95b3df
502         .quad   0x4d2c6dfc5ac42aed,0x53380d139d95b3df
503         .quad   0x650a73548baf63de,0x766a0abb3c77b2a8
504         .quad   0x650a73548baf63de,0x766a0abb3c77b2a8
505         .quad   0x81c2c92e47edaee6,0x92722c851482353b
506         .quad   0x81c2c92e47edaee6,0x92722c851482353b
507         .quad   0xa2bfe8a14cf10364,0xa81a664bbc423001
508         .quad   0xa2bfe8a14cf10364,0xa81a664bbc423001
509         .quad   0xc24b8b70d0f89791,0xc76c51a30654be30
510         .quad   0xc24b8b70d0f89791,0xc76c51a30654be30
511         .quad   0xd192e819d6ef5218,0xd69906245565a910
512         .quad   0xd192e819d6ef5218,0xd69906245565a910
513         .quad   0xf40e35855771202a,0x106aa07032bbd1b8
514         .quad   0xf40e35855771202a,0x106aa07032bbd1b8
515         .quad   0x19a4c116b8d2d0c8,0x1e376c085141ab53
516         .quad   0x19a4c116b8d2d0c8,0x1e376c085141ab53
517         .quad   0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
518         .quad   0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
519         .quad   0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
520         .quad   0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
521         .quad   0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
522         .quad   0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
523         .quad   0x748f82ee5defb2fc,0x78a5636f43172f60
524         .quad   0x748f82ee5defb2fc,0x78a5636f43172f60
525         .quad   0x84c87814a1f0ab72,0x8cc702081a6439ec
526         .quad   0x84c87814a1f0ab72,0x8cc702081a6439ec
527         .quad   0x90befffa23631e28,0xa4506cebde82bde9
528         .quad   0x90befffa23631e28,0xa4506cebde82bde9
529         .quad   0xbef9a3f7b2c67915,0xc67178f2e372532b
530         .quad   0xbef9a3f7b2c67915,0xc67178f2e372532b
531         .quad   0xca273eceea26619c,0xd186b8c721c0c207
532         .quad   0xca273eceea26619c,0xd186b8c721c0c207
533         .quad   0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
534         .quad   0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
535         .quad   0x06f067aa72176fba,0x0a637dc5a2c898a6
536         .quad   0x06f067aa72176fba,0x0a637dc5a2c898a6
537         .quad   0x113f9804bef90dae,0x1b710b35131c471b
538         .quad   0x113f9804bef90dae,0x1b710b35131c471b
539         .quad   0x28db77f523047d84,0x32caab7b40c72493
540         .quad   0x28db77f523047d84,0x32caab7b40c72493
541         .quad   0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
542         .quad   0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
543         .quad   0x4cc5d4becb3e42b6,0x597f299cfc657e2a
544         .quad   0x4cc5d4becb3e42b6,0x597f299cfc657e2a
545         .quad   0x5fcb6fab3ad6faec,0x6c44198c4a475817
546         .quad   0x5fcb6fab3ad6faec,0x6c44198c4a475817
547
548         .quad   0x0001020304050607,0x08090a0b0c0d0e0f
549         .quad   0x0001020304050607,0x08090a0b0c0d0e0f
550         .asciz  "SHA512 block transform for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
551 ___
552 }
553
554 ######################################################################
555 # SIMD code paths
556 #
557 if ($SZ==4 && $shaext) {{{
558 ######################################################################
559 # Intel SHA Extensions implementation of SHA256 update function.
560 #
561 my ($ctx,$inp,$num,$Tbl)=("%rdi","%rsi","%rdx","%rcx");
562
563 my ($Wi,$ABEF,$CDGH,$TMP,$BSWAP,$ABEF_SAVE,$CDGH_SAVE)=map("%xmm$_",(0..2,7..10));
564 my @MSG=map("%xmm$_",(3..6));
565
566 $code.=<<___;
567 .type   sha256_block_data_order_shaext,\@function,3
568 .align  64
569 sha256_block_data_order_shaext:
570 _shaext_shortcut:
571 ___
572 $code.=<<___ if ($win64);
573         lea     `-8-5*16`(%rsp),%rsp
574         movaps  %xmm6,-8-5*16(%rax)
575         movaps  %xmm7,-8-4*16(%rax)
576         movaps  %xmm8,-8-3*16(%rax)
577         movaps  %xmm9,-8-2*16(%rax)
578         movaps  %xmm10,-8-1*16(%rax)
579 .Lprologue_shaext:
580 ___
581 $code.=<<___;
582         lea             K256+0x80(%rip),$Tbl
583         movdqu          ($ctx),$ABEF            # DCBA
584         movdqu          16($ctx),$CDGH          # HGFE
585         movdqa          0x200-0x80($Tbl),$TMP   # byte swap mask
586
587         pshufd          \$0x1b,$ABEF,$Wi        # ABCD
588         pshufd          \$0xb1,$ABEF,$ABEF      # CDAB
589         pshufd          \$0x1b,$CDGH,$CDGH      # EFGH
590         movdqa          $TMP,$BSWAP             # offload
591         palignr         \$8,$CDGH,$ABEF         # ABEF
592         punpcklqdq      $Wi,$CDGH               # CDGH
593         jmp             .Loop_shaext
594
595 .align  16
596 .Loop_shaext:
597         movdqu          ($inp),@MSG[0]
598         movdqu          0x10($inp),@MSG[1]
599         movdqu          0x20($inp),@MSG[2]
600         pshufb          $TMP,@MSG[0]
601         movdqu          0x30($inp),@MSG[3]
602
603         movdqa          0*32-0x80($Tbl),$Wi
604         paddd           @MSG[0],$Wi
605         pshufb          $TMP,@MSG[1]
606         movdqa          $CDGH,$CDGH_SAVE        # offload
607         sha256rnds2     $ABEF,$CDGH             # 0-3
608         pshufd          \$0x0e,$Wi,$Wi
609         nop
610         movdqa          $ABEF,$ABEF_SAVE        # offload
611         sha256rnds2     $CDGH,$ABEF
612
613         movdqa          1*32-0x80($Tbl),$Wi
614         paddd           @MSG[1],$Wi
615         pshufb          $TMP,@MSG[2]
616         sha256rnds2     $ABEF,$CDGH             # 4-7
617         pshufd          \$0x0e,$Wi,$Wi
618         lea             0x40($inp),$inp
619         sha256msg1      @MSG[1],@MSG[0]
620         sha256rnds2     $CDGH,$ABEF
621
622         movdqa          2*32-0x80($Tbl),$Wi
623         paddd           @MSG[2],$Wi
624         pshufb          $TMP,@MSG[3]
625         sha256rnds2     $ABEF,$CDGH             # 8-11
626         pshufd          \$0x0e,$Wi,$Wi
627         movdqa          @MSG[3],$TMP
628         palignr         \$4,@MSG[2],$TMP
629         nop
630         paddd           $TMP,@MSG[0]
631         sha256msg1      @MSG[2],@MSG[1]
632         sha256rnds2     $CDGH,$ABEF
633
634         movdqa          3*32-0x80($Tbl),$Wi
635         paddd           @MSG[3],$Wi
636         sha256msg2      @MSG[3],@MSG[0]
637         sha256rnds2     $ABEF,$CDGH             # 12-15
638         pshufd          \$0x0e,$Wi,$Wi
639         movdqa          @MSG[0],$TMP
640         palignr         \$4,@MSG[3],$TMP
641         nop
642         paddd           $TMP,@MSG[1]
643         sha256msg1      @MSG[3],@MSG[2]
644         sha256rnds2     $CDGH,$ABEF
645 ___
646 for($i=4;$i<16-3;$i++) {
647 $code.=<<___;
648         movdqa          $i*32-0x80($Tbl),$Wi
649         paddd           @MSG[0],$Wi
650         sha256msg2      @MSG[0],@MSG[1]
651         sha256rnds2     $ABEF,$CDGH             # 16-19...
652         pshufd          \$0x0e,$Wi,$Wi
653         movdqa          @MSG[1],$TMP
654         palignr         \$4,@MSG[0],$TMP
655         nop
656         paddd           $TMP,@MSG[2]
657         sha256msg1      @MSG[0],@MSG[3]
658         sha256rnds2     $CDGH,$ABEF
659 ___
660         push(@MSG,shift(@MSG));
661 }
662 $code.=<<___;
663         movdqa          13*32-0x80($Tbl),$Wi
664         paddd           @MSG[0],$Wi
665         sha256msg2      @MSG[0],@MSG[1]
666         sha256rnds2     $ABEF,$CDGH             # 52-55
667         pshufd          \$0x0e,$Wi,$Wi
668         movdqa          @MSG[1],$TMP
669         palignr         \$4,@MSG[0],$TMP
670         sha256rnds2     $CDGH,$ABEF
671         paddd           $TMP,@MSG[2]
672
673         movdqa          14*32-0x80($Tbl),$Wi
674         paddd           @MSG[1],$Wi
675         sha256rnds2     $ABEF,$CDGH             # 56-59
676         pshufd          \$0x0e,$Wi,$Wi
677         sha256msg2      @MSG[1],@MSG[2]
678         movdqa          $BSWAP,$TMP
679         sha256rnds2     $CDGH,$ABEF
680
681         movdqa          15*32-0x80($Tbl),$Wi
682         paddd           @MSG[2],$Wi
683         nop
684         sha256rnds2     $ABEF,$CDGH             # 60-63
685         pshufd          \$0x0e,$Wi,$Wi
686         dec             $num
687         nop
688         sha256rnds2     $CDGH,$ABEF
689
690         paddd           $CDGH_SAVE,$CDGH
691         paddd           $ABEF_SAVE,$ABEF
692         jnz             .Loop_shaext
693
694         pshufd          \$0xb1,$CDGH,$CDGH      # DCHG
695         pshufd          \$0x1b,$ABEF,$TMP       # FEBA
696         pshufd          \$0xb1,$ABEF,$ABEF      # BAFE
697         punpckhqdq      $CDGH,$ABEF             # DCBA
698         palignr         \$8,$TMP,$CDGH          # HGFE
699
700         movdqu  $ABEF,($ctx)
701         movdqu  $CDGH,16($ctx)
702 ___
703 $code.=<<___ if ($win64);
704         movaps  -8-5*16(%rax),%xmm6
705         movaps  -8-4*16(%rax),%xmm7
706         movaps  -8-3*16(%rax),%xmm8
707         movaps  -8-2*16(%rax),%xmm9
708         movaps  -8-1*16(%rax),%xmm10
709         mov     %rax,%rsp
710 .Lepilogue_shaext:
711 ___
712 $code.=<<___;
713         ret
714 .size   sha256_block_data_order_shaext,.-sha256_block_data_order_shaext
715 ___
716 }}}
717 {{{
718
719 my $a4=$T1;
720 my ($a,$b,$c,$d,$e,$f,$g,$h);
721
722 sub AUTOLOAD()          # thunk [simplified] 32-bit style perlasm
723 { my $opcode = $AUTOLOAD; $opcode =~ s/.*:://;
724   my $arg = pop;
725     $arg = "\$$arg" if ($arg*1 eq $arg);
726     $code .= "\t$opcode\t".join(',',$arg,reverse @_)."\n";
727 }
728
729 sub body_00_15 () {
730         (
731         '($a,$b,$c,$d,$e,$f,$g,$h)=@ROT;'.
732
733         '&ror   ($a0,$Sigma1[2]-$Sigma1[1])',
734         '&mov   ($a,$a1)',
735         '&mov   ($a4,$f)',
736
737         '&ror   ($a1,$Sigma0[2]-$Sigma0[1])',
738         '&xor   ($a0,$e)',
739         '&xor   ($a4,$g)',                      # f^g
740
741         '&ror   ($a0,$Sigma1[1]-$Sigma1[0])',
742         '&xor   ($a1,$a)',
743         '&and   ($a4,$e)',                      # (f^g)&e
744
745         '&xor   ($a0,$e)',
746         '&add   ($h,$SZ*($i&15)."(%rsp)")',     # h+=X[i]+K[i]
747         '&mov   ($a2,$a)',
748
749         '&xor   ($a4,$g)',                      # Ch(e,f,g)=((f^g)&e)^g
750         '&ror   ($a1,$Sigma0[1]-$Sigma0[0])',
751         '&xor   ($a2,$b)',                      # a^b, b^c in next round
752
753         '&add   ($h,$a4)',                      # h+=Ch(e,f,g)
754         '&ror   ($a0,$Sigma1[0])',              # Sigma1(e)
755         '&and   ($a3,$a2)',                     # (b^c)&(a^b)
756
757         '&xor   ($a1,$a)',
758         '&add   ($h,$a0)',                      # h+=Sigma1(e)
759         '&xor   ($a3,$b)',                      # Maj(a,b,c)=Ch(a^b,c,b)
760
761         '&ror   ($a1,$Sigma0[0])',              # Sigma0(a)
762         '&add   ($d,$h)',                       # d+=h
763         '&add   ($h,$a3)',                      # h+=Maj(a,b,c)
764
765         '&mov   ($a0,$d)',
766         '&add   ($a1,$h);'.                     # h+=Sigma0(a)
767         '($a2,$a3) = ($a3,$a2); unshift(@ROT,pop(@ROT)); $i++;'
768         );
769 }
770
771 ######################################################################
772 # SSSE3 code path
773 #
774 if ($SZ==4) {   # SHA256 only
775 my @X = map("%xmm$_",(0..3));
776 my ($t0,$t1,$t2,$t3, $t4,$t5) = map("%xmm$_",(4..9));
777
778 $code.=<<___;
779 .type   ${func}_ssse3,\@function,3
780 .align  64
781 ${func}_ssse3:
782 .cfi_startproc
783 .Lssse3_shortcut:
784         mov     %rsp,%rax               # copy %rsp
785 .cfi_def_cfa_register   %rax
786         push    %rbx
787 .cfi_push       %rbx
788         push    %rbp
789 .cfi_push       %rbp
790         push    %r12
791 .cfi_push       %r12
792         push    %r13
793 .cfi_push       %r13
794         push    %r14
795 .cfi_push       %r14
796         push    %r15
797 .cfi_push       %r15
798         shl     \$4,%rdx                # num*16
799         sub     \$`$framesz+$win64*16*4`,%rsp
800         lea     ($inp,%rdx,$SZ),%rdx    # inp+num*16*$SZ
801         and     \$-64,%rsp              # align stack frame
802         mov     $ctx,$_ctx              # save ctx, 1st arg
803         mov     $inp,$_inp              # save inp, 2nd arh
804         mov     %rdx,$_end              # save end pointer, "3rd" arg
805         mov     %rax,$_rsp              # save copy of %rsp
806 .cfi_cfa_expression     $_rsp,deref,+8
807 ___
808 $code.=<<___ if ($win64);
809         movaps  %xmm6,16*$SZ+32(%rsp)
810         movaps  %xmm7,16*$SZ+48(%rsp)
811         movaps  %xmm8,16*$SZ+64(%rsp)
812         movaps  %xmm9,16*$SZ+80(%rsp)
813 ___
814 $code.=<<___;
815 .Lprologue_ssse3:
816
817         mov     $SZ*0($ctx),$A
818         mov     $SZ*1($ctx),$B
819         mov     $SZ*2($ctx),$C
820         mov     $SZ*3($ctx),$D
821         mov     $SZ*4($ctx),$E
822         mov     $SZ*5($ctx),$F
823         mov     $SZ*6($ctx),$G
824         mov     $SZ*7($ctx),$H
825 ___
826
827 $code.=<<___;
828         #movdqa $TABLE+`$SZ*2*$rounds`+32(%rip),$t4
829         #movdqa $TABLE+`$SZ*2*$rounds`+64(%rip),$t5
830         jmp     .Lloop_ssse3
831 .align  16
832 .Lloop_ssse3:
833         movdqa  $TABLE+`$SZ*2*$rounds`(%rip),$t3
834         movdqu  0x00($inp),@X[0]
835         movdqu  0x10($inp),@X[1]
836         movdqu  0x20($inp),@X[2]
837         pshufb  $t3,@X[0]
838         movdqu  0x30($inp),@X[3]
839         lea     $TABLE(%rip),$Tbl
840         pshufb  $t3,@X[1]
841         movdqa  0x00($Tbl),$t0
842         movdqa  0x20($Tbl),$t1
843         pshufb  $t3,@X[2]
844         paddd   @X[0],$t0
845         movdqa  0x40($Tbl),$t2
846         pshufb  $t3,@X[3]
847         movdqa  0x60($Tbl),$t3
848         paddd   @X[1],$t1
849         paddd   @X[2],$t2
850         paddd   @X[3],$t3
851         movdqa  $t0,0x00(%rsp)
852         mov     $A,$a1
853         movdqa  $t1,0x10(%rsp)
854         mov     $B,$a3
855         movdqa  $t2,0x20(%rsp)
856         xor     $C,$a3                  # magic
857         movdqa  $t3,0x30(%rsp)
858         mov     $E,$a0
859         jmp     .Lssse3_00_47
860
861 .align  16
862 .Lssse3_00_47:
863         sub     \$`-16*2*$SZ`,$Tbl      # size optimization
864 ___
865 sub Xupdate_256_SSSE3 () {
866         (
867         '&movdqa        ($t0,@X[1]);',
868         '&movdqa        ($t3,@X[3])',
869         '&palignr       ($t0,@X[0],$SZ)',       # X[1..4]
870          '&palignr      ($t3,@X[2],$SZ);',      # X[9..12]
871         '&movdqa        ($t1,$t0)',
872         '&movdqa        ($t2,$t0);',
873         '&psrld         ($t0,$sigma0[2])',
874          '&paddd        (@X[0],$t3);',          # X[0..3] += X[9..12]
875         '&psrld         ($t2,$sigma0[0])',
876          '&pshufd       ($t3,@X[3],0b11111010)',# X[14..15]
877         '&pslld         ($t1,8*$SZ-$sigma0[1]);'.
878         '&pxor          ($t0,$t2)',
879         '&psrld         ($t2,$sigma0[1]-$sigma0[0]);'.
880         '&pxor          ($t0,$t1)',
881         '&pslld         ($t1,$sigma0[1]-$sigma0[0]);'.
882         '&pxor          ($t0,$t2);',
883          '&movdqa       ($t2,$t3)',
884         '&pxor          ($t0,$t1);',            # sigma0(X[1..4])
885          '&psrld        ($t3,$sigma1[2])',
886         '&paddd         (@X[0],$t0);',          # X[0..3] += sigma0(X[1..4])
887          '&psrlq        ($t2,$sigma1[0])',
888          '&pxor         ($t3,$t2);',
889          '&psrlq        ($t2,$sigma1[1]-$sigma1[0])',
890          '&pxor         ($t3,$t2)',
891          '&pshufb       ($t3,$t4)',             # sigma1(X[14..15])
892         '&paddd         (@X[0],$t3)',           # X[0..1] += sigma1(X[14..15])
893          '&pshufd       ($t3,@X[0],0b01010000)',# X[16..17]
894          '&movdqa       ($t2,$t3);',
895          '&psrld        ($t3,$sigma1[2])',
896          '&psrlq        ($t2,$sigma1[0])',
897          '&pxor         ($t3,$t2);',
898          '&psrlq        ($t2,$sigma1[1]-$sigma1[0])',
899          '&pxor         ($t3,$t2);',
900         '&movdqa        ($t2,16*2*$j."($Tbl)")',
901          '&pshufb       ($t3,$t5)',
902         '&paddd         (@X[0],$t3)'            # X[2..3] += sigma1(X[16..17])
903         );
904 }
905
906 sub SSSE3_256_00_47 () {
907 my $j = shift;
908 my $body = shift;
909 my @X = @_;
910 my @insns = (&$body,&$body,&$body,&$body);      # 104 instructions
911
912     if (0) {
913         foreach (Xupdate_256_SSSE3()) {         # 36 instructions
914             eval;
915             eval(shift(@insns));
916             eval(shift(@insns));
917             eval(shift(@insns));
918         }
919     } else {                    # squeeze extra 4% on Westmere and 19% on Atom
920           eval(shift(@insns));  #@
921         &movdqa         ($t0,@X[1]);
922           eval(shift(@insns));
923           eval(shift(@insns));
924         &movdqa         ($t3,@X[3]);
925           eval(shift(@insns));  #@
926           eval(shift(@insns));
927           eval(shift(@insns));
928           eval(shift(@insns));  #@
929           eval(shift(@insns));
930         &palignr        ($t0,@X[0],$SZ);        # X[1..4]
931           eval(shift(@insns));
932           eval(shift(@insns));
933          &palignr       ($t3,@X[2],$SZ);        # X[9..12]
934           eval(shift(@insns));
935           eval(shift(@insns));
936           eval(shift(@insns));
937           eval(shift(@insns));  #@
938         &movdqa         ($t1,$t0);
939           eval(shift(@insns));
940           eval(shift(@insns));
941         &movdqa         ($t2,$t0);
942           eval(shift(@insns));  #@
943           eval(shift(@insns));
944         &psrld          ($t0,$sigma0[2]);
945           eval(shift(@insns));
946           eval(shift(@insns));
947           eval(shift(@insns));
948          &paddd         (@X[0],$t3);            # X[0..3] += X[9..12]
949           eval(shift(@insns));  #@
950           eval(shift(@insns));
951         &psrld          ($t2,$sigma0[0]);
952           eval(shift(@insns));
953           eval(shift(@insns));
954          &pshufd        ($t3,@X[3],0b11111010); # X[4..15]
955           eval(shift(@insns));
956           eval(shift(@insns));  #@
957         &pslld          ($t1,8*$SZ-$sigma0[1]);
958           eval(shift(@insns));
959           eval(shift(@insns));
960         &pxor           ($t0,$t2);
961           eval(shift(@insns));  #@
962           eval(shift(@insns));
963           eval(shift(@insns));
964           eval(shift(@insns));  #@
965         &psrld          ($t2,$sigma0[1]-$sigma0[0]);
966           eval(shift(@insns));
967         &pxor           ($t0,$t1);
968           eval(shift(@insns));
969           eval(shift(@insns));
970         &pslld          ($t1,$sigma0[1]-$sigma0[0]);
971           eval(shift(@insns));
972           eval(shift(@insns));
973         &pxor           ($t0,$t2);
974           eval(shift(@insns));
975           eval(shift(@insns));  #@
976          &movdqa        ($t2,$t3);
977           eval(shift(@insns));
978           eval(shift(@insns));
979         &pxor           ($t0,$t1);              # sigma0(X[1..4])
980           eval(shift(@insns));  #@
981           eval(shift(@insns));
982           eval(shift(@insns));
983          &psrld         ($t3,$sigma1[2]);
984           eval(shift(@insns));
985           eval(shift(@insns));
986         &paddd          (@X[0],$t0);            # X[0..3] += sigma0(X[1..4])
987           eval(shift(@insns));  #@
988           eval(shift(@insns));
989          &psrlq         ($t2,$sigma1[0]);
990           eval(shift(@insns));
991           eval(shift(@insns));
992           eval(shift(@insns));
993          &pxor          ($t3,$t2);
994           eval(shift(@insns));  #@
995           eval(shift(@insns));
996           eval(shift(@insns));
997           eval(shift(@insns));  #@
998          &psrlq         ($t2,$sigma1[1]-$sigma1[0]);
999           eval(shift(@insns));
1000           eval(shift(@insns));
1001          &pxor          ($t3,$t2);
1002           eval(shift(@insns));  #@
1003           eval(shift(@insns));
1004           eval(shift(@insns));
1005          #&pshufb       ($t3,$t4);              # sigma1(X[14..15])
1006          &pshufd        ($t3,$t3,0b10000000);
1007           eval(shift(@insns));
1008           eval(shift(@insns));
1009           eval(shift(@insns));
1010          &psrldq        ($t3,8);
1011           eval(shift(@insns));
1012           eval(shift(@insns));  #@
1013           eval(shift(@insns));
1014           eval(shift(@insns));
1015           eval(shift(@insns));  #@
1016         &paddd          (@X[0],$t3);            # X[0..1] += sigma1(X[14..15])
1017           eval(shift(@insns));
1018           eval(shift(@insns));
1019           eval(shift(@insns));
1020          &pshufd        ($t3,@X[0],0b01010000); # X[16..17]
1021           eval(shift(@insns));
1022           eval(shift(@insns));  #@
1023           eval(shift(@insns));
1024          &movdqa        ($t2,$t3);
1025           eval(shift(@insns));
1026           eval(shift(@insns));
1027          &psrld         ($t3,$sigma1[2]);
1028           eval(shift(@insns));
1029           eval(shift(@insns));  #@
1030          &psrlq         ($t2,$sigma1[0]);
1031           eval(shift(@insns));
1032           eval(shift(@insns));
1033          &pxor          ($t3,$t2);
1034           eval(shift(@insns));  #@
1035           eval(shift(@insns));
1036           eval(shift(@insns));
1037           eval(shift(@insns));  #@
1038           eval(shift(@insns));
1039          &psrlq         ($t2,$sigma1[1]-$sigma1[0]);
1040           eval(shift(@insns));
1041           eval(shift(@insns));
1042           eval(shift(@insns));
1043          &pxor          ($t3,$t2);
1044           eval(shift(@insns));
1045           eval(shift(@insns));
1046           eval(shift(@insns));  #@
1047          #&pshufb       ($t3,$t5);
1048          &pshufd        ($t3,$t3,0b00001000);
1049           eval(shift(@insns));
1050           eval(shift(@insns));
1051         &movdqa         ($t2,16*2*$j."($Tbl)");
1052           eval(shift(@insns));  #@
1053           eval(shift(@insns));
1054          &pslldq        ($t3,8);
1055           eval(shift(@insns));
1056           eval(shift(@insns));
1057           eval(shift(@insns));
1058         &paddd          (@X[0],$t3);            # X[2..3] += sigma1(X[16..17])
1059           eval(shift(@insns));  #@
1060           eval(shift(@insns));
1061           eval(shift(@insns));
1062     }
1063         &paddd          ($t2,@X[0]);
1064           foreach (@insns) { eval; }            # remaining instructions
1065         &movdqa         (16*$j."(%rsp)",$t2);
1066 }
1067
1068     for ($i=0,$j=0; $j<4; $j++) {
1069         &SSSE3_256_00_47($j,\&body_00_15,@X);
1070         push(@X,shift(@X));                     # rotate(@X)
1071     }
1072         &cmpb   ($SZ-1+16*2*$SZ."($Tbl)",0);
1073         &jne    (".Lssse3_00_47");
1074
1075     for ($i=0; $i<16; ) {
1076         foreach(body_00_15()) { eval; }
1077     }
1078 $code.=<<___;
1079         mov     $_ctx,$ctx
1080         mov     $a1,$A
1081
1082         add     $SZ*0($ctx),$A
1083         lea     16*$SZ($inp),$inp
1084         add     $SZ*1($ctx),$B
1085         add     $SZ*2($ctx),$C
1086         add     $SZ*3($ctx),$D
1087         add     $SZ*4($ctx),$E
1088         add     $SZ*5($ctx),$F
1089         add     $SZ*6($ctx),$G
1090         add     $SZ*7($ctx),$H
1091
1092         cmp     $_end,$inp
1093
1094         mov     $A,$SZ*0($ctx)
1095         mov     $B,$SZ*1($ctx)
1096         mov     $C,$SZ*2($ctx)
1097         mov     $D,$SZ*3($ctx)
1098         mov     $E,$SZ*4($ctx)
1099         mov     $F,$SZ*5($ctx)
1100         mov     $G,$SZ*6($ctx)
1101         mov     $H,$SZ*7($ctx)
1102         jb      .Lloop_ssse3
1103
1104         mov     $_rsp,%rsi
1105 .cfi_def_cfa    %rsi,8
1106 ___
1107 $code.=<<___ if ($win64);
1108         movaps  16*$SZ+32(%rsp),%xmm6
1109         movaps  16*$SZ+48(%rsp),%xmm7
1110         movaps  16*$SZ+64(%rsp),%xmm8
1111         movaps  16*$SZ+80(%rsp),%xmm9
1112 ___
1113 $code.=<<___;
1114         mov     -48(%rsi),%r15
1115 .cfi_restore    %r15
1116         mov     -40(%rsi),%r14
1117 .cfi_restore    %r14
1118         mov     -32(%rsi),%r13
1119 .cfi_restore    %r13
1120         mov     -24(%rsi),%r12
1121 .cfi_restore    %r12
1122         mov     -16(%rsi),%rbp
1123 .cfi_restore    %rbp
1124         mov     -8(%rsi),%rbx
1125 .cfi_restore    %rbx
1126         lea     (%rsi),%rsp
1127 .cfi_def_cfa_register   %rsp
1128 .Lepilogue_ssse3:
1129         ret
1130 .cfi_endproc
1131 .size   ${func}_ssse3,.-${func}_ssse3
1132 ___
1133 }
1134
1135 if ($avx) {{
1136 ######################################################################
1137 # XOP code path
1138 #
1139 if ($SZ==8) {   # SHA512 only
1140 $code.=<<___;
1141 .type   ${func}_xop,\@function,3
1142 .align  64
1143 ${func}_xop:
1144 .cfi_startproc
1145 .Lxop_shortcut:
1146         mov     %rsp,%rax               # copy %rsp
1147 .cfi_def_cfa_register   %rax
1148         push    %rbx
1149 .cfi_push       %rbx
1150         push    %rbp
1151 .cfi_push       %rbp
1152         push    %r12
1153 .cfi_push       %r12
1154         push    %r13
1155 .cfi_push       %r13
1156         push    %r14
1157 .cfi_push       %r14
1158         push    %r15
1159 .cfi_push       %r15
1160         shl     \$4,%rdx                # num*16
1161         sub     \$`$framesz+$win64*16*($SZ==4?4:6)`,%rsp
1162         lea     ($inp,%rdx,$SZ),%rdx    # inp+num*16*$SZ
1163         and     \$-64,%rsp              # align stack frame
1164         mov     $ctx,$_ctx              # save ctx, 1st arg
1165         mov     $inp,$_inp              # save inp, 2nd arh
1166         mov     %rdx,$_end              # save end pointer, "3rd" arg
1167         mov     %rax,$_rsp              # save copy of %rsp
1168 .cfi_cfa_expression     $_rsp,deref,+8
1169 ___
1170 $code.=<<___ if ($win64);
1171         movaps  %xmm6,16*$SZ+32(%rsp)
1172         movaps  %xmm7,16*$SZ+48(%rsp)
1173         movaps  %xmm8,16*$SZ+64(%rsp)
1174         movaps  %xmm9,16*$SZ+80(%rsp)
1175 ___
1176 $code.=<<___ if ($win64 && $SZ>4);
1177         movaps  %xmm10,16*$SZ+96(%rsp)
1178         movaps  %xmm11,16*$SZ+112(%rsp)
1179 ___
1180 $code.=<<___;
1181 .Lprologue_xop:
1182
1183         vzeroupper
1184         mov     $SZ*0($ctx),$A
1185         mov     $SZ*1($ctx),$B
1186         mov     $SZ*2($ctx),$C
1187         mov     $SZ*3($ctx),$D
1188         mov     $SZ*4($ctx),$E
1189         mov     $SZ*5($ctx),$F
1190         mov     $SZ*6($ctx),$G
1191         mov     $SZ*7($ctx),$H
1192         jmp     .Lloop_xop
1193 ___
1194                                         if ($SZ==4) {   # SHA256
1195     my @X = map("%xmm$_",(0..3));
1196     my ($t0,$t1,$t2,$t3) = map("%xmm$_",(4..7));
1197
1198 $code.=<<___;
1199 .align  16
1200 .Lloop_xop:
1201         vmovdqa $TABLE+`$SZ*2*$rounds`(%rip),$t3
1202         vmovdqu 0x00($inp),@X[0]
1203         vmovdqu 0x10($inp),@X[1]
1204         vmovdqu 0x20($inp),@X[2]
1205         vmovdqu 0x30($inp),@X[3]
1206         vpshufb $t3,@X[0],@X[0]
1207         lea     $TABLE(%rip),$Tbl
1208         vpshufb $t3,@X[1],@X[1]
1209         vpshufb $t3,@X[2],@X[2]
1210         vpaddd  0x00($Tbl),@X[0],$t0
1211         vpshufb $t3,@X[3],@X[3]
1212         vpaddd  0x20($Tbl),@X[1],$t1
1213         vpaddd  0x40($Tbl),@X[2],$t2
1214         vpaddd  0x60($Tbl),@X[3],$t3
1215         vmovdqa $t0,0x00(%rsp)
1216         mov     $A,$a1
1217         vmovdqa $t1,0x10(%rsp)
1218         mov     $B,$a3
1219         vmovdqa $t2,0x20(%rsp)
1220         xor     $C,$a3                  # magic
1221         vmovdqa $t3,0x30(%rsp)
1222         mov     $E,$a0
1223         jmp     .Lxop_00_47
1224
1225 .align  16
1226 .Lxop_00_47:
1227         sub     \$`-16*2*$SZ`,$Tbl      # size optimization
1228 ___
1229 sub XOP_256_00_47 () {
1230 my $j = shift;
1231 my $body = shift;
1232 my @X = @_;
1233 my @insns = (&$body,&$body,&$body,&$body);      # 104 instructions
1234
1235         &vpalignr       ($t0,@X[1],@X[0],$SZ);  # X[1..4]
1236           eval(shift(@insns));
1237           eval(shift(@insns));
1238          &vpalignr      ($t3,@X[3],@X[2],$SZ);  # X[9..12]
1239           eval(shift(@insns));
1240           eval(shift(@insns));
1241         &vprotd         ($t1,$t0,8*$SZ-$sigma0[1]);
1242           eval(shift(@insns));
1243           eval(shift(@insns));
1244         &vpsrld         ($t0,$t0,$sigma0[2]);
1245           eval(shift(@insns));
1246           eval(shift(@insns));
1247          &vpaddd        (@X[0],@X[0],$t3);      # X[0..3] += X[9..12]
1248           eval(shift(@insns));
1249           eval(shift(@insns));
1250           eval(shift(@insns));
1251           eval(shift(@insns));
1252         &vprotd         ($t2,$t1,$sigma0[1]-$sigma0[0]);
1253           eval(shift(@insns));
1254           eval(shift(@insns));
1255         &vpxor          ($t0,$t0,$t1);
1256           eval(shift(@insns));
1257           eval(shift(@insns));
1258           eval(shift(@insns));
1259           eval(shift(@insns));
1260          &vprotd        ($t3,@X[3],8*$SZ-$sigma1[1]);
1261           eval(shift(@insns));
1262           eval(shift(@insns));
1263         &vpxor          ($t0,$t0,$t2);          # sigma0(X[1..4])
1264           eval(shift(@insns));
1265           eval(shift(@insns));
1266          &vpsrld        ($t2,@X[3],$sigma1[2]);
1267           eval(shift(@insns));
1268           eval(shift(@insns));
1269         &vpaddd         (@X[0],@X[0],$t0);      # X[0..3] += sigma0(X[1..4])
1270           eval(shift(@insns));
1271           eval(shift(@insns));
1272          &vprotd        ($t1,$t3,$sigma1[1]-$sigma1[0]);
1273           eval(shift(@insns));
1274           eval(shift(@insns));
1275          &vpxor         ($t3,$t3,$t2);
1276           eval(shift(@insns));
1277           eval(shift(@insns));
1278           eval(shift(@insns));
1279           eval(shift(@insns));
1280          &vpxor         ($t3,$t3,$t1);          # sigma1(X[14..15])
1281           eval(shift(@insns));
1282           eval(shift(@insns));
1283           eval(shift(@insns));
1284           eval(shift(@insns));
1285         &vpsrldq        ($t3,$t3,8);
1286           eval(shift(@insns));
1287           eval(shift(@insns));
1288           eval(shift(@insns));
1289           eval(shift(@insns));
1290         &vpaddd         (@X[0],@X[0],$t3);      # X[0..1] += sigma1(X[14..15])
1291           eval(shift(@insns));
1292           eval(shift(@insns));
1293           eval(shift(@insns));
1294           eval(shift(@insns));
1295          &vprotd        ($t3,@X[0],8*$SZ-$sigma1[1]);
1296           eval(shift(@insns));
1297           eval(shift(@insns));
1298          &vpsrld        ($t2,@X[0],$sigma1[2]);
1299           eval(shift(@insns));
1300           eval(shift(@insns));
1301          &vprotd        ($t1,$t3,$sigma1[1]-$sigma1[0]);
1302           eval(shift(@insns));
1303           eval(shift(@insns));
1304          &vpxor         ($t3,$t3,$t2);
1305           eval(shift(@insns));
1306           eval(shift(@insns));
1307           eval(shift(@insns));
1308           eval(shift(@insns));
1309          &vpxor         ($t3,$t3,$t1);          # sigma1(X[16..17])
1310           eval(shift(@insns));
1311           eval(shift(@insns));
1312           eval(shift(@insns));
1313           eval(shift(@insns));
1314         &vpslldq        ($t3,$t3,8);            # 22 instructions
1315           eval(shift(@insns));
1316           eval(shift(@insns));
1317           eval(shift(@insns));
1318           eval(shift(@insns));
1319         &vpaddd         (@X[0],@X[0],$t3);      # X[2..3] += sigma1(X[16..17])
1320           eval(shift(@insns));
1321           eval(shift(@insns));
1322           eval(shift(@insns));
1323           eval(shift(@insns));
1324         &vpaddd         ($t2,@X[0],16*2*$j."($Tbl)");
1325           foreach (@insns) { eval; }            # remaining instructions
1326         &vmovdqa        (16*$j."(%rsp)",$t2);
1327 }
1328
1329     for ($i=0,$j=0; $j<4; $j++) {
1330         &XOP_256_00_47($j,\&body_00_15,@X);
1331         push(@X,shift(@X));                     # rotate(@X)
1332     }
1333         &cmpb   ($SZ-1+16*2*$SZ."($Tbl)",0);
1334         &jne    (".Lxop_00_47");
1335
1336     for ($i=0; $i<16; ) {
1337         foreach(body_00_15()) { eval; }
1338     }
1339
1340                                         } else {        # SHA512
1341     my @X = map("%xmm$_",(0..7));
1342     my ($t0,$t1,$t2,$t3) = map("%xmm$_",(8..11));
1343
1344 $code.=<<___;
1345 .align  16
1346 .Lloop_xop:
1347         vmovdqa $TABLE+`$SZ*2*$rounds`(%rip),$t3
1348         vmovdqu 0x00($inp),@X[0]
1349         lea     $TABLE+0x80(%rip),$Tbl  # size optimization
1350         vmovdqu 0x10($inp),@X[1]
1351         vmovdqu 0x20($inp),@X[2]
1352         vpshufb $t3,@X[0],@X[0]
1353         vmovdqu 0x30($inp),@X[3]
1354         vpshufb $t3,@X[1],@X[1]
1355         vmovdqu 0x40($inp),@X[4]
1356         vpshufb $t3,@X[2],@X[2]
1357         vmovdqu 0x50($inp),@X[5]
1358         vpshufb $t3,@X[3],@X[3]
1359         vmovdqu 0x60($inp),@X[6]
1360         vpshufb $t3,@X[4],@X[4]
1361         vmovdqu 0x70($inp),@X[7]
1362         vpshufb $t3,@X[5],@X[5]
1363         vpaddq  -0x80($Tbl),@X[0],$t0
1364         vpshufb $t3,@X[6],@X[6]
1365         vpaddq  -0x60($Tbl),@X[1],$t1
1366         vpshufb $t3,@X[7],@X[7]
1367         vpaddq  -0x40($Tbl),@X[2],$t2
1368         vpaddq  -0x20($Tbl),@X[3],$t3
1369         vmovdqa $t0,0x00(%rsp)
1370         vpaddq  0x00($Tbl),@X[4],$t0
1371         vmovdqa $t1,0x10(%rsp)
1372         vpaddq  0x20($Tbl),@X[5],$t1
1373         vmovdqa $t2,0x20(%rsp)
1374         vpaddq  0x40($Tbl),@X[6],$t2
1375         vmovdqa $t3,0x30(%rsp)
1376         vpaddq  0x60($Tbl),@X[7],$t3
1377         vmovdqa $t0,0x40(%rsp)
1378         mov     $A,$a1
1379         vmovdqa $t1,0x50(%rsp)
1380         mov     $B,$a3
1381         vmovdqa $t2,0x60(%rsp)
1382         xor     $C,$a3                  # magic
1383         vmovdqa $t3,0x70(%rsp)
1384         mov     $E,$a0
1385         jmp     .Lxop_00_47
1386
1387 .align  16
1388 .Lxop_00_47:
1389         add     \$`16*2*$SZ`,$Tbl
1390 ___
1391 sub XOP_512_00_47 () {
1392 my $j = shift;
1393 my $body = shift;
1394 my @X = @_;
1395 my @insns = (&$body,&$body);                    # 52 instructions
1396
1397         &vpalignr       ($t0,@X[1],@X[0],$SZ);  # X[1..2]
1398           eval(shift(@insns));
1399           eval(shift(@insns));
1400          &vpalignr      ($t3,@X[5],@X[4],$SZ);  # X[9..10]
1401           eval(shift(@insns));
1402           eval(shift(@insns));
1403         &vprotq         ($t1,$t0,8*$SZ-$sigma0[1]);
1404           eval(shift(@insns));
1405           eval(shift(@insns));
1406         &vpsrlq         ($t0,$t0,$sigma0[2]);
1407           eval(shift(@insns));
1408           eval(shift(@insns));
1409          &vpaddq        (@X[0],@X[0],$t3);      # X[0..1] += X[9..10]
1410           eval(shift(@insns));
1411           eval(shift(@insns));
1412           eval(shift(@insns));
1413           eval(shift(@insns));
1414         &vprotq         ($t2,$t1,$sigma0[1]-$sigma0[0]);
1415           eval(shift(@insns));
1416           eval(shift(@insns));
1417         &vpxor          ($t0,$t0,$t1);
1418           eval(shift(@insns));
1419           eval(shift(@insns));
1420           eval(shift(@insns));
1421           eval(shift(@insns));
1422          &vprotq        ($t3,@X[7],8*$SZ-$sigma1[1]);
1423           eval(shift(@insns));
1424           eval(shift(@insns));
1425         &vpxor          ($t0,$t0,$t2);          # sigma0(X[1..2])
1426           eval(shift(@insns));
1427           eval(shift(@insns));
1428          &vpsrlq        ($t2,@X[7],$sigma1[2]);
1429           eval(shift(@insns));
1430           eval(shift(@insns));
1431         &vpaddq         (@X[0],@X[0],$t0);      # X[0..1] += sigma0(X[1..2])
1432           eval(shift(@insns));
1433           eval(shift(@insns));
1434          &vprotq        ($t1,$t3,$sigma1[1]-$sigma1[0]);
1435           eval(shift(@insns));
1436           eval(shift(@insns));
1437          &vpxor         ($t3,$t3,$t2);
1438           eval(shift(@insns));
1439           eval(shift(@insns));
1440           eval(shift(@insns));
1441           eval(shift(@insns));
1442          &vpxor         ($t3,$t3,$t1);          # sigma1(X[14..15])
1443           eval(shift(@insns));
1444           eval(shift(@insns));
1445           eval(shift(@insns));
1446           eval(shift(@insns));
1447         &vpaddq         (@X[0],@X[0],$t3);      # X[0..1] += sigma1(X[14..15])
1448           eval(shift(@insns));
1449           eval(shift(@insns));
1450           eval(shift(@insns));
1451           eval(shift(@insns));
1452         &vpaddq         ($t2,@X[0],16*2*$j-0x80."($Tbl)");
1453           foreach (@insns) { eval; }            # remaining instructions
1454         &vmovdqa        (16*$j."(%rsp)",$t2);
1455 }
1456
1457     for ($i=0,$j=0; $j<8; $j++) {
1458         &XOP_512_00_47($j,\&body_00_15,@X);
1459         push(@X,shift(@X));                     # rotate(@X)
1460     }
1461         &cmpb   ($SZ-1+16*2*$SZ-0x80."($Tbl)",0);
1462         &jne    (".Lxop_00_47");
1463
1464     for ($i=0; $i<16; ) {
1465         foreach(body_00_15()) { eval; }
1466     }
1467 }
1468 $code.=<<___;
1469         mov     $_ctx,$ctx
1470         mov     $a1,$A
1471
1472         add     $SZ*0($ctx),$A
1473         lea     16*$SZ($inp),$inp
1474         add     $SZ*1($ctx),$B
1475         add     $SZ*2($ctx),$C
1476         add     $SZ*3($ctx),$D
1477         add     $SZ*4($ctx),$E
1478         add     $SZ*5($ctx),$F
1479         add     $SZ*6($ctx),$G
1480         add     $SZ*7($ctx),$H
1481
1482         cmp     $_end,$inp
1483
1484         mov     $A,$SZ*0($ctx)
1485         mov     $B,$SZ*1($ctx)
1486         mov     $C,$SZ*2($ctx)
1487         mov     $D,$SZ*3($ctx)
1488         mov     $E,$SZ*4($ctx)
1489         mov     $F,$SZ*5($ctx)
1490         mov     $G,$SZ*6($ctx)
1491         mov     $H,$SZ*7($ctx)
1492         jb      .Lloop_xop
1493
1494         mov     $_rsp,%rsi
1495 .cfi_def_cfa    %rsi,8
1496         vzeroupper
1497 ___
1498 $code.=<<___ if ($win64);
1499         movaps  16*$SZ+32(%rsp),%xmm6
1500         movaps  16*$SZ+48(%rsp),%xmm7
1501         movaps  16*$SZ+64(%rsp),%xmm8
1502         movaps  16*$SZ+80(%rsp),%xmm9
1503 ___
1504 $code.=<<___ if ($win64 && $SZ>4);
1505         movaps  16*$SZ+96(%rsp),%xmm10
1506         movaps  16*$SZ+112(%rsp),%xmm11
1507 ___
1508 $code.=<<___;
1509         mov     -48(%rsi),%r15
1510 .cfi_restore    %r15
1511         mov     -40(%rsi),%r14
1512 .cfi_restore    %r14
1513         mov     -32(%rsi),%r13
1514 .cfi_restore    %r13
1515         mov     -24(%rsi),%r12
1516 .cfi_restore    %r12
1517         mov     -16(%rsi),%rbp
1518 .cfi_restore    %rbp
1519         mov     -8(%rsi),%rbx
1520 .cfi_restore    %rbx
1521         lea     (%rsi),%rsp
1522 .cfi_def_cfa_register   %rsp
1523 .Lepilogue_xop:
1524         ret
1525 .cfi_endproc
1526 .size   ${func}_xop,.-${func}_xop
1527 ___
1528 }
1529 ######################################################################
1530 # AVX+shrd code path
1531 #
1532 local *ror = sub { &shrd(@_[0],@_) };
1533
1534 $code.=<<___;
1535 .type   ${func}_avx,\@function,3
1536 .align  64
1537 ${func}_avx:
1538 .cfi_startproc
1539 .Lavx_shortcut:
1540         mov     %rsp,%rax               # copy %rsp
1541 .cfi_def_cfa_register   %rax
1542         push    %rbx
1543 .cfi_push       %rbx
1544         push    %rbp
1545 .cfi_push       %rbp
1546         push    %r12
1547 .cfi_push       %r12
1548         push    %r13
1549 .cfi_push       %r13
1550         push    %r14
1551 .cfi_push       %r14
1552         push    %r15
1553 .cfi_push       %r15
1554         shl     \$4,%rdx                # num*16
1555         sub     \$`$framesz+$win64*16*($SZ==4?4:6)`,%rsp
1556         lea     ($inp,%rdx,$SZ),%rdx    # inp+num*16*$SZ
1557         and     \$-64,%rsp              # align stack frame
1558         mov     $ctx,$_ctx              # save ctx, 1st arg
1559         mov     $inp,$_inp              # save inp, 2nd arh
1560         mov     %rdx,$_end              # save end pointer, "3rd" arg
1561         mov     %rax,$_rsp              # save copy of %rsp
1562 .cfi_cfa_expression     $_rsp,deref,+8
1563 ___
1564 $code.=<<___ if ($win64);
1565         movaps  %xmm6,16*$SZ+32(%rsp)
1566         movaps  %xmm7,16*$SZ+48(%rsp)
1567         movaps  %xmm8,16*$SZ+64(%rsp)
1568         movaps  %xmm9,16*$SZ+80(%rsp)
1569 ___
1570 $code.=<<___ if ($win64 && $SZ>4);
1571         movaps  %xmm10,16*$SZ+96(%rsp)
1572         movaps  %xmm11,16*$SZ+112(%rsp)
1573 ___
1574 $code.=<<___;
1575 .Lprologue_avx:
1576
1577         vzeroupper
1578         mov     $SZ*0($ctx),$A
1579         mov     $SZ*1($ctx),$B
1580         mov     $SZ*2($ctx),$C
1581         mov     $SZ*3($ctx),$D
1582         mov     $SZ*4($ctx),$E
1583         mov     $SZ*5($ctx),$F
1584         mov     $SZ*6($ctx),$G
1585         mov     $SZ*7($ctx),$H
1586 ___
1587                                         if ($SZ==4) {   # SHA256
1588     my @X = map("%xmm$_",(0..3));
1589     my ($t0,$t1,$t2,$t3, $t4,$t5) = map("%xmm$_",(4..9));
1590
1591 $code.=<<___;
1592         vmovdqa $TABLE+`$SZ*2*$rounds`+32(%rip),$t4
1593         vmovdqa $TABLE+`$SZ*2*$rounds`+64(%rip),$t5
1594         jmp     .Lloop_avx
1595 .align  16
1596 .Lloop_avx:
1597         vmovdqa $TABLE+`$SZ*2*$rounds`(%rip),$t3
1598         vmovdqu 0x00($inp),@X[0]
1599         vmovdqu 0x10($inp),@X[1]
1600         vmovdqu 0x20($inp),@X[2]
1601         vmovdqu 0x30($inp),@X[3]
1602         vpshufb $t3,@X[0],@X[0]
1603         lea     $TABLE(%rip),$Tbl
1604         vpshufb $t3,@X[1],@X[1]
1605         vpshufb $t3,@X[2],@X[2]
1606         vpaddd  0x00($Tbl),@X[0],$t0
1607         vpshufb $t3,@X[3],@X[3]
1608         vpaddd  0x20($Tbl),@X[1],$t1
1609         vpaddd  0x40($Tbl),@X[2],$t2
1610         vpaddd  0x60($Tbl),@X[3],$t3
1611         vmovdqa $t0,0x00(%rsp)
1612         mov     $A,$a1
1613         vmovdqa $t1,0x10(%rsp)
1614         mov     $B,$a3
1615         vmovdqa $t2,0x20(%rsp)
1616         xor     $C,$a3                  # magic
1617         vmovdqa $t3,0x30(%rsp)
1618         mov     $E,$a0
1619         jmp     .Lavx_00_47
1620
1621 .align  16
1622 .Lavx_00_47:
1623         sub     \$`-16*2*$SZ`,$Tbl      # size optimization
1624 ___
1625 sub Xupdate_256_AVX () {
1626         (
1627         '&vpalignr      ($t0,@X[1],@X[0],$SZ)', # X[1..4]
1628          '&vpalignr     ($t3,@X[3],@X[2],$SZ)', # X[9..12]
1629         '&vpsrld        ($t2,$t0,$sigma0[0]);',
1630          '&vpaddd       (@X[0],@X[0],$t3)',     # X[0..3] += X[9..12]
1631         '&vpsrld        ($t3,$t0,$sigma0[2])',
1632         '&vpslld        ($t1,$t0,8*$SZ-$sigma0[1]);',
1633         '&vpxor         ($t0,$t3,$t2)',
1634          '&vpshufd      ($t3,@X[3],0b11111010)',# X[14..15]
1635         '&vpsrld        ($t2,$t2,$sigma0[1]-$sigma0[0]);',
1636         '&vpxor         ($t0,$t0,$t1)',
1637         '&vpslld        ($t1,$t1,$sigma0[1]-$sigma0[0]);',
1638         '&vpxor         ($t0,$t0,$t2)',
1639          '&vpsrld       ($t2,$t3,$sigma1[2]);',
1640         '&vpxor         ($t0,$t0,$t1)',         # sigma0(X[1..4])
1641          '&vpsrlq       ($t3,$t3,$sigma1[0]);',
1642         '&vpaddd        (@X[0],@X[0],$t0)',     # X[0..3] += sigma0(X[1..4])
1643          '&vpxor        ($t2,$t2,$t3);',
1644          '&vpsrlq       ($t3,$t3,$sigma1[1]-$sigma1[0])',
1645          '&vpxor        ($t2,$t2,$t3)',
1646          '&vpshufb      ($t2,$t2,$t4)',         # sigma1(X[14..15])
1647         '&vpaddd        (@X[0],@X[0],$t2)',     # X[0..1] += sigma1(X[14..15])
1648          '&vpshufd      ($t3,@X[0],0b01010000)',# X[16..17]
1649          '&vpsrld       ($t2,$t3,$sigma1[2])',
1650          '&vpsrlq       ($t3,$t3,$sigma1[0])',
1651          '&vpxor        ($t2,$t2,$t3);',
1652          '&vpsrlq       ($t3,$t3,$sigma1[1]-$sigma1[0])',
1653          '&vpxor        ($t2,$t2,$t3)',
1654          '&vpshufb      ($t2,$t2,$t5)',
1655         '&vpaddd        (@X[0],@X[0],$t2)'      # X[2..3] += sigma1(X[16..17])
1656         );
1657 }
1658
1659 sub AVX_256_00_47 () {
1660 my $j = shift;
1661 my $body = shift;
1662 my @X = @_;
1663 my @insns = (&$body,&$body,&$body,&$body);      # 104 instructions
1664
1665         foreach (Xupdate_256_AVX()) {           # 29 instructions
1666             eval;
1667             eval(shift(@insns));
1668             eval(shift(@insns));
1669             eval(shift(@insns));
1670         }
1671         &vpaddd         ($t2,@X[0],16*2*$j."($Tbl)");
1672           foreach (@insns) { eval; }            # remaining instructions
1673         &vmovdqa        (16*$j."(%rsp)",$t2);
1674 }
1675
1676     for ($i=0,$j=0; $j<4; $j++) {
1677         &AVX_256_00_47($j,\&body_00_15,@X);
1678         push(@X,shift(@X));                     # rotate(@X)
1679     }
1680         &cmpb   ($SZ-1+16*2*$SZ."($Tbl)",0);
1681         &jne    (".Lavx_00_47");
1682
1683     for ($i=0; $i<16; ) {
1684         foreach(body_00_15()) { eval; }
1685     }
1686
1687                                         } else {        # SHA512
1688     my @X = map("%xmm$_",(0..7));
1689     my ($t0,$t1,$t2,$t3) = map("%xmm$_",(8..11));
1690
1691 $code.=<<___;
1692         jmp     .Lloop_avx
1693 .align  16
1694 .Lloop_avx:
1695         vmovdqa $TABLE+`$SZ*2*$rounds`(%rip),$t3
1696         vmovdqu 0x00($inp),@X[0]
1697         lea     $TABLE+0x80(%rip),$Tbl  # size optimization
1698         vmovdqu 0x10($inp),@X[1]
1699         vmovdqu 0x20($inp),@X[2]
1700         vpshufb $t3,@X[0],@X[0]
1701         vmovdqu 0x30($inp),@X[3]
1702         vpshufb $t3,@X[1],@X[1]
1703         vmovdqu 0x40($inp),@X[4]
1704         vpshufb $t3,@X[2],@X[2]
1705         vmovdqu 0x50($inp),@X[5]
1706         vpshufb $t3,@X[3],@X[3]
1707         vmovdqu 0x60($inp),@X[6]
1708         vpshufb $t3,@X[4],@X[4]
1709         vmovdqu 0x70($inp),@X[7]
1710         vpshufb $t3,@X[5],@X[5]
1711         vpaddq  -0x80($Tbl),@X[0],$t0
1712         vpshufb $t3,@X[6],@X[6]
1713         vpaddq  -0x60($Tbl),@X[1],$t1
1714         vpshufb $t3,@X[7],@X[7]
1715         vpaddq  -0x40($Tbl),@X[2],$t2
1716         vpaddq  -0x20($Tbl),@X[3],$t3
1717         vmovdqa $t0,0x00(%rsp)
1718         vpaddq  0x00($Tbl),@X[4],$t0
1719         vmovdqa $t1,0x10(%rsp)
1720         vpaddq  0x20($Tbl),@X[5],$t1
1721         vmovdqa $t2,0x20(%rsp)
1722         vpaddq  0x40($Tbl),@X[6],$t2
1723         vmovdqa $t3,0x30(%rsp)
1724         vpaddq  0x60($Tbl),@X[7],$t3
1725         vmovdqa $t0,0x40(%rsp)
1726         mov     $A,$a1
1727         vmovdqa $t1,0x50(%rsp)
1728         mov     $B,$a3
1729         vmovdqa $t2,0x60(%rsp)
1730         xor     $C,$a3                  # magic
1731         vmovdqa $t3,0x70(%rsp)
1732         mov     $E,$a0
1733         jmp     .Lavx_00_47
1734
1735 .align  16
1736 .Lavx_00_47:
1737         add     \$`16*2*$SZ`,$Tbl
1738 ___
1739 sub Xupdate_512_AVX () {
1740         (
1741         '&vpalignr      ($t0,@X[1],@X[0],$SZ)', # X[1..2]
1742          '&vpalignr     ($t3,@X[5],@X[4],$SZ)', # X[9..10]
1743         '&vpsrlq        ($t2,$t0,$sigma0[0])',
1744          '&vpaddq       (@X[0],@X[0],$t3);',    # X[0..1] += X[9..10]
1745         '&vpsrlq        ($t3,$t0,$sigma0[2])',
1746         '&vpsllq        ($t1,$t0,8*$SZ-$sigma0[1]);',
1747          '&vpxor        ($t0,$t3,$t2)',
1748         '&vpsrlq        ($t2,$t2,$sigma0[1]-$sigma0[0]);',
1749          '&vpxor        ($t0,$t0,$t1)',
1750         '&vpsllq        ($t1,$t1,$sigma0[1]-$sigma0[0]);',
1751          '&vpxor        ($t0,$t0,$t2)',
1752          '&vpsrlq       ($t3,@X[7],$sigma1[2]);',
1753         '&vpxor         ($t0,$t0,$t1)',         # sigma0(X[1..2])
1754          '&vpsllq       ($t2,@X[7],8*$SZ-$sigma1[1]);',
1755         '&vpaddq        (@X[0],@X[0],$t0)',     # X[0..1] += sigma0(X[1..2])
1756          '&vpsrlq       ($t1,@X[7],$sigma1[0]);',
1757          '&vpxor        ($t3,$t3,$t2)',
1758          '&vpsllq       ($t2,$t2,$sigma1[1]-$sigma1[0]);',
1759          '&vpxor        ($t3,$t3,$t1)',
1760          '&vpsrlq       ($t1,$t1,$sigma1[1]-$sigma1[0]);',
1761          '&vpxor        ($t3,$t3,$t2)',
1762          '&vpxor        ($t3,$t3,$t1)',         # sigma1(X[14..15])
1763         '&vpaddq        (@X[0],@X[0],$t3)',     # X[0..1] += sigma1(X[14..15])
1764         );
1765 }
1766
1767 sub AVX_512_00_47 () {
1768 my $j = shift;
1769 my $body = shift;
1770 my @X = @_;
1771 my @insns = (&$body,&$body);                    # 52 instructions
1772
1773         foreach (Xupdate_512_AVX()) {           # 23 instructions
1774             eval;
1775             eval(shift(@insns));
1776             eval(shift(@insns));
1777         }
1778         &vpaddq         ($t2,@X[0],16*2*$j-0x80."($Tbl)");
1779           foreach (@insns) { eval; }            # remaining instructions
1780         &vmovdqa        (16*$j."(%rsp)",$t2);
1781 }
1782
1783     for ($i=0,$j=0; $j<8; $j++) {
1784         &AVX_512_00_47($j,\&body_00_15,@X);
1785         push(@X,shift(@X));                     # rotate(@X)
1786     }
1787         &cmpb   ($SZ-1+16*2*$SZ-0x80."($Tbl)",0);
1788         &jne    (".Lavx_00_47");
1789
1790     for ($i=0; $i<16; ) {
1791         foreach(body_00_15()) { eval; }
1792     }
1793 }
1794 $code.=<<___;
1795         mov     $_ctx,$ctx
1796         mov     $a1,$A
1797
1798         add     $SZ*0($ctx),$A
1799         lea     16*$SZ($inp),$inp
1800         add     $SZ*1($ctx),$B
1801         add     $SZ*2($ctx),$C
1802         add     $SZ*3($ctx),$D
1803         add     $SZ*4($ctx),$E
1804         add     $SZ*5($ctx),$F
1805         add     $SZ*6($ctx),$G
1806         add     $SZ*7($ctx),$H
1807
1808         cmp     $_end,$inp
1809
1810         mov     $A,$SZ*0($ctx)
1811         mov     $B,$SZ*1($ctx)
1812         mov     $C,$SZ*2($ctx)
1813         mov     $D,$SZ*3($ctx)
1814         mov     $E,$SZ*4($ctx)
1815         mov     $F,$SZ*5($ctx)
1816         mov     $G,$SZ*6($ctx)
1817         mov     $H,$SZ*7($ctx)
1818         jb      .Lloop_avx
1819
1820         mov     $_rsp,%rsi
1821 .cfi_def_cfa    %rsi,8
1822         vzeroupper
1823 ___
1824 $code.=<<___ if ($win64);
1825         movaps  16*$SZ+32(%rsp),%xmm6
1826         movaps  16*$SZ+48(%rsp),%xmm7
1827         movaps  16*$SZ+64(%rsp),%xmm8
1828         movaps  16*$SZ+80(%rsp),%xmm9
1829 ___
1830 $code.=<<___ if ($win64 && $SZ>4);
1831         movaps  16*$SZ+96(%rsp),%xmm10
1832         movaps  16*$SZ+112(%rsp),%xmm11
1833 ___
1834 $code.=<<___;
1835         mov     -48(%rsi),%r15
1836 .cfi_restore    %r15
1837         mov     -40(%rsi),%r14
1838 .cfi_restore    %r14
1839         mov     -32(%rsi),%r13
1840 .cfi_restore    %r13
1841         mov     -24(%rsi),%r12
1842 .cfi_restore    %r12
1843         mov     -16(%rsi),%rbp
1844 .cfi_restore    %rbp
1845         mov     -8(%rsi),%rbx
1846 .cfi_restore    %rbx
1847         lea     (%rsi),%rsp
1848 .cfi_def_cfa_register   %rsp
1849 .Lepilogue_avx:
1850         ret
1851 .cfi_endproc
1852 .size   ${func}_avx,.-${func}_avx
1853 ___
1854
1855 if ($avx>1) {{
1856 ######################################################################
1857 # AVX2+BMI code path
1858 #
1859 my $a5=$SZ==4?"%esi":"%rsi";    # zap $inp
1860 my $PUSH8=8*2*$SZ;
1861 use integer;
1862
1863 sub bodyx_00_15 () {
1864         # at start $a1 should be zero, $a3 - $b^$c and $a4 copy of $f
1865         (
1866         '($a,$b,$c,$d,$e,$f,$g,$h)=@ROT;'.
1867
1868         '&add   ($h,(32*($i/(16/$SZ))+$SZ*($i%(16/$SZ)))%$PUSH8.$base)',    # h+=X[i]+K[i]
1869         '&and   ($a4,$e)',              # f&e
1870         '&rorx  ($a0,$e,$Sigma1[2])',
1871         '&rorx  ($a2,$e,$Sigma1[1])',
1872
1873         '&lea   ($a,"($a,$a1)")',       # h+=Sigma0(a) from the past
1874         '&lea   ($h,"($h,$a4)")',
1875         '&andn  ($a4,$e,$g)',           # ~e&g
1876         '&xor   ($a0,$a2)',
1877
1878         '&rorx  ($a1,$e,$Sigma1[0])',
1879         '&lea   ($h,"($h,$a4)")',       # h+=Ch(e,f,g)=(e&f)+(~e&g)
1880         '&xor   ($a0,$a1)',             # Sigma1(e)
1881         '&mov   ($a2,$a)',
1882
1883         '&rorx  ($a4,$a,$Sigma0[2])',
1884         '&lea   ($h,"($h,$a0)")',       # h+=Sigma1(e)
1885         '&xor   ($a2,$b)',              # a^b, b^c in next round
1886         '&rorx  ($a1,$a,$Sigma0[1])',
1887
1888         '&rorx  ($a0,$a,$Sigma0[0])',
1889         '&lea   ($d,"($d,$h)")',        # d+=h
1890         '&and   ($a3,$a2)',             # (b^c)&(a^b)
1891         '&xor   ($a1,$a4)',
1892
1893         '&xor   ($a3,$b)',              # Maj(a,b,c)=Ch(a^b,c,b)
1894         '&xor   ($a1,$a0)',             # Sigma0(a)
1895         '&lea   ($h,"($h,$a3)");'.      # h+=Maj(a,b,c)
1896         '&mov   ($a4,$e)',              # copy of f in future
1897
1898         '($a2,$a3) = ($a3,$a2); unshift(@ROT,pop(@ROT)); $i++;'
1899         );
1900         # and at the finish one has to $a+=$a1
1901 }
1902
1903 $code.=<<___;
1904 .type   ${func}_avx2,\@function,3
1905 .align  64
1906 ${func}_avx2:
1907 .cfi_startproc
1908 .Lavx2_shortcut:
1909         mov     %rsp,%rax               # copy %rsp
1910 .cfi_def_cfa_register   %rax
1911         push    %rbx
1912 .cfi_push       %rbx
1913         push    %rbp
1914 .cfi_push       %rbp
1915         push    %r12
1916 .cfi_push       %r12
1917         push    %r13
1918 .cfi_push       %r13
1919         push    %r14
1920 .cfi_push       %r14
1921         push    %r15
1922 .cfi_push       %r15
1923         sub     \$`2*$SZ*$rounds+4*8+$win64*16*($SZ==4?4:6)`,%rsp
1924         shl     \$4,%rdx                # num*16
1925         and     \$-256*$SZ,%rsp         # align stack frame
1926         lea     ($inp,%rdx,$SZ),%rdx    # inp+num*16*$SZ
1927         add     \$`2*$SZ*($rounds-8)`,%rsp
1928         mov     $ctx,$_ctx              # save ctx, 1st arg
1929         mov     $inp,$_inp              # save inp, 2nd arh
1930         mov     %rdx,$_end              # save end pointer, "3rd" arg
1931         mov     %rax,$_rsp              # save copy of %rsp
1932 .cfi_cfa_expression     $_rsp,deref,+8
1933 ___
1934 $code.=<<___ if ($win64);
1935         movaps  %xmm6,16*$SZ+32(%rsp)
1936         movaps  %xmm7,16*$SZ+48(%rsp)
1937         movaps  %xmm8,16*$SZ+64(%rsp)
1938         movaps  %xmm9,16*$SZ+80(%rsp)
1939 ___
1940 $code.=<<___ if ($win64 && $SZ>4);
1941         movaps  %xmm10,16*$SZ+96(%rsp)
1942         movaps  %xmm11,16*$SZ+112(%rsp)
1943 ___
1944 $code.=<<___;
1945 .Lprologue_avx2:
1946
1947         vzeroupper
1948         sub     \$-16*$SZ,$inp          # inp++, size optimization
1949         mov     $SZ*0($ctx),$A
1950         mov     $inp,%r12               # borrow $T1
1951         mov     $SZ*1($ctx),$B
1952         cmp     %rdx,$inp               # $_end
1953         mov     $SZ*2($ctx),$C
1954         cmove   %rsp,%r12               # next block or random data
1955         mov     $SZ*3($ctx),$D
1956         mov     $SZ*4($ctx),$E
1957         mov     $SZ*5($ctx),$F
1958         mov     $SZ*6($ctx),$G
1959         mov     $SZ*7($ctx),$H
1960 ___
1961                                         if ($SZ==4) {   # SHA256
1962     my @X = map("%ymm$_",(0..3));
1963     my ($t0,$t1,$t2,$t3, $t4,$t5) = map("%ymm$_",(4..9));
1964
1965 $code.=<<___;
1966         vmovdqa $TABLE+`$SZ*2*$rounds`+32(%rip),$t4
1967         vmovdqa $TABLE+`$SZ*2*$rounds`+64(%rip),$t5
1968         jmp     .Loop_avx2
1969 .align  16
1970 .Loop_avx2:
1971         vmovdqa $TABLE+`$SZ*2*$rounds`(%rip),$t3
1972         vmovdqu -16*$SZ+0($inp),%xmm0
1973         vmovdqu -16*$SZ+16($inp),%xmm1
1974         vmovdqu -16*$SZ+32($inp),%xmm2
1975         vmovdqu -16*$SZ+48($inp),%xmm3
1976         #mov            $inp,$_inp      # offload $inp
1977         vinserti128     \$1,(%r12),@X[0],@X[0]
1978         vinserti128     \$1,16(%r12),@X[1],@X[1]
1979         vpshufb         $t3,@X[0],@X[0]
1980         vinserti128     \$1,32(%r12),@X[2],@X[2]
1981         vpshufb         $t3,@X[1],@X[1]
1982         vinserti128     \$1,48(%r12),@X[3],@X[3]
1983
1984         lea     $TABLE(%rip),$Tbl
1985         vpshufb $t3,@X[2],@X[2]
1986         vpaddd  0x00($Tbl),@X[0],$t0
1987         vpshufb $t3,@X[3],@X[3]
1988         vpaddd  0x20($Tbl),@X[1],$t1
1989         vpaddd  0x40($Tbl),@X[2],$t2
1990         vpaddd  0x60($Tbl),@X[3],$t3
1991         vmovdqa $t0,0x00(%rsp)
1992         xor     $a1,$a1
1993         vmovdqa $t1,0x20(%rsp)
1994         lea     -$PUSH8(%rsp),%rsp
1995         mov     $B,$a3
1996         vmovdqa $t2,0x00(%rsp)
1997         xor     $C,$a3                  # magic
1998         vmovdqa $t3,0x20(%rsp)
1999         mov     $F,$a4
2000         sub     \$-16*2*$SZ,$Tbl        # size optimization
2001         jmp     .Lavx2_00_47
2002
2003 .align  16
2004 .Lavx2_00_47:
2005 ___
2006
2007 sub AVX2_256_00_47 () {
2008 my $j = shift;
2009 my $body = shift;
2010 my @X = @_;
2011 my @insns = (&$body,&$body,&$body,&$body);      # 96 instructions
2012 my $base = "+2*$PUSH8(%rsp)";
2013
2014         &lea    ("%rsp","-$PUSH8(%rsp)")        if (($j%2)==0);
2015         foreach (Xupdate_256_AVX()) {           # 29 instructions
2016             eval;
2017             eval(shift(@insns));
2018             eval(shift(@insns));
2019             eval(shift(@insns));
2020         }
2021         &vpaddd         ($t2,@X[0],16*2*$j."($Tbl)");
2022           foreach (@insns) { eval; }            # remaining instructions
2023         &vmovdqa        ((32*$j)%$PUSH8."(%rsp)",$t2);
2024 }
2025
2026     for ($i=0,$j=0; $j<4; $j++) {
2027         &AVX2_256_00_47($j,\&bodyx_00_15,@X);
2028         push(@X,shift(@X));                     # rotate(@X)
2029     }
2030         &lea    ($Tbl,16*2*$SZ."($Tbl)");
2031         &cmpb   (($SZ-1)."($Tbl)",0);
2032         &jne    (".Lavx2_00_47");
2033
2034     for ($i=0; $i<16; ) {
2035         my $base=$i<8?"+$PUSH8(%rsp)":"(%rsp)";
2036         foreach(bodyx_00_15()) { eval; }
2037     }
2038                                         } else {        # SHA512
2039     my @X = map("%ymm$_",(0..7));
2040     my ($t0,$t1,$t2,$t3) = map("%ymm$_",(8..11));
2041
2042 $code.=<<___;
2043         jmp     .Loop_avx2
2044 .align  16
2045 .Loop_avx2:
2046         vmovdqu -16*$SZ($inp),%xmm0
2047         vmovdqu -16*$SZ+16($inp),%xmm1
2048         vmovdqu -16*$SZ+32($inp),%xmm2
2049         lea     $TABLE+0x80(%rip),$Tbl  # size optimization
2050         vmovdqu -16*$SZ+48($inp),%xmm3
2051         vmovdqu -16*$SZ+64($inp),%xmm4
2052         vmovdqu -16*$SZ+80($inp),%xmm5
2053         vmovdqu -16*$SZ+96($inp),%xmm6
2054         vmovdqu -16*$SZ+112($inp),%xmm7
2055         #mov    $inp,$_inp      # offload $inp
2056         vmovdqa `$SZ*2*$rounds-0x80`($Tbl),$t2
2057         vinserti128     \$1,(%r12),@X[0],@X[0]
2058         vinserti128     \$1,16(%r12),@X[1],@X[1]
2059          vpshufb        $t2,@X[0],@X[0]
2060         vinserti128     \$1,32(%r12),@X[2],@X[2]
2061          vpshufb        $t2,@X[1],@X[1]
2062         vinserti128     \$1,48(%r12),@X[3],@X[3]
2063          vpshufb        $t2,@X[2],@X[2]
2064         vinserti128     \$1,64(%r12),@X[4],@X[4]
2065          vpshufb        $t2,@X[3],@X[3]
2066         vinserti128     \$1,80(%r12),@X[5],@X[5]
2067          vpshufb        $t2,@X[4],@X[4]
2068         vinserti128     \$1,96(%r12),@X[6],@X[6]
2069          vpshufb        $t2,@X[5],@X[5]
2070         vinserti128     \$1,112(%r12),@X[7],@X[7]
2071
2072         vpaddq  -0x80($Tbl),@X[0],$t0
2073         vpshufb $t2,@X[6],@X[6]
2074         vpaddq  -0x60($Tbl),@X[1],$t1
2075         vpshufb $t2,@X[7],@X[7]
2076         vpaddq  -0x40($Tbl),@X[2],$t2
2077         vpaddq  -0x20($Tbl),@X[3],$t3
2078         vmovdqa $t0,0x00(%rsp)
2079         vpaddq  0x00($Tbl),@X[4],$t0
2080         vmovdqa $t1,0x20(%rsp)
2081         vpaddq  0x20($Tbl),@X[5],$t1
2082         vmovdqa $t2,0x40(%rsp)
2083         vpaddq  0x40($Tbl),@X[6],$t2
2084         vmovdqa $t3,0x60(%rsp)
2085         lea     -$PUSH8(%rsp),%rsp
2086         vpaddq  0x60($Tbl),@X[7],$t3
2087         vmovdqa $t0,0x00(%rsp)
2088         xor     $a1,$a1
2089         vmovdqa $t1,0x20(%rsp)
2090         mov     $B,$a3
2091         vmovdqa $t2,0x40(%rsp)
2092         xor     $C,$a3                  # magic
2093         vmovdqa $t3,0x60(%rsp)
2094         mov     $F,$a4
2095         add     \$16*2*$SZ,$Tbl
2096         jmp     .Lavx2_00_47
2097
2098 .align  16
2099 .Lavx2_00_47:
2100 ___
2101
2102 sub AVX2_512_00_47 () {
2103 my $j = shift;
2104 my $body = shift;
2105 my @X = @_;
2106 my @insns = (&$body,&$body);                    # 48 instructions
2107 my $base = "+2*$PUSH8(%rsp)";
2108
2109         &lea    ("%rsp","-$PUSH8(%rsp)")        if (($j%4)==0);
2110         foreach (Xupdate_512_AVX()) {           # 23 instructions
2111             eval;
2112             if ($_ !~ /\;$/) {
2113                 eval(shift(@insns));
2114                 eval(shift(@insns));
2115                 eval(shift(@insns));
2116             }
2117         }
2118         &vpaddq         ($t2,@X[0],16*2*$j-0x80."($Tbl)");
2119           foreach (@insns) { eval; }            # remaining instructions
2120         &vmovdqa        ((32*$j)%$PUSH8."(%rsp)",$t2);
2121 }
2122
2123     for ($i=0,$j=0; $j<8; $j++) {
2124         &AVX2_512_00_47($j,\&bodyx_00_15,@X);
2125         push(@X,shift(@X));                     # rotate(@X)
2126     }
2127         &lea    ($Tbl,16*2*$SZ."($Tbl)");
2128         &cmpb   (($SZ-1-0x80)."($Tbl)",0);
2129         &jne    (".Lavx2_00_47");
2130
2131     for ($i=0; $i<16; ) {
2132         my $base=$i<8?"+$PUSH8(%rsp)":"(%rsp)";
2133         foreach(bodyx_00_15()) { eval; }
2134     }
2135 }
2136 $code.=<<___;
2137         mov     `2*$SZ*$rounds`(%rsp),$ctx      # $_ctx
2138         add     $a1,$A
2139         #mov    `2*$SZ*$rounds+8`(%rsp),$inp    # $_inp
2140         lea     `2*$SZ*($rounds-8)`(%rsp),$Tbl
2141
2142         add     $SZ*0($ctx),$A
2143         add     $SZ*1($ctx),$B
2144         add     $SZ*2($ctx),$C
2145         add     $SZ*3($ctx),$D
2146         add     $SZ*4($ctx),$E
2147         add     $SZ*5($ctx),$F
2148         add     $SZ*6($ctx),$G
2149         add     $SZ*7($ctx),$H
2150
2151         mov     $A,$SZ*0($ctx)
2152         mov     $B,$SZ*1($ctx)
2153         mov     $C,$SZ*2($ctx)
2154         mov     $D,$SZ*3($ctx)
2155         mov     $E,$SZ*4($ctx)
2156         mov     $F,$SZ*5($ctx)
2157         mov     $G,$SZ*6($ctx)
2158         mov     $H,$SZ*7($ctx)
2159
2160         cmp     `$PUSH8+2*8`($Tbl),$inp # $_end
2161         je      .Ldone_avx2
2162
2163         xor     $a1,$a1
2164         mov     $B,$a3
2165         xor     $C,$a3                  # magic
2166         mov     $F,$a4
2167         jmp     .Lower_avx2
2168 .align  16
2169 .Lower_avx2:
2170 ___
2171     for ($i=0; $i<8; ) {
2172         my $base="+16($Tbl)";
2173         foreach(bodyx_00_15()) { eval; }
2174     }
2175 $code.=<<___;
2176         lea     -$PUSH8($Tbl),$Tbl
2177         cmp     %rsp,$Tbl
2178         jae     .Lower_avx2
2179
2180         mov     `2*$SZ*$rounds`(%rsp),$ctx      # $_ctx
2181         add     $a1,$A
2182         #mov    `2*$SZ*$rounds+8`(%rsp),$inp    # $_inp
2183         lea     `2*$SZ*($rounds-8)`(%rsp),%rsp
2184
2185         add     $SZ*0($ctx),$A
2186         add     $SZ*1($ctx),$B
2187         add     $SZ*2($ctx),$C
2188         add     $SZ*3($ctx),$D
2189         add     $SZ*4($ctx),$E
2190         add     $SZ*5($ctx),$F
2191         lea     `2*16*$SZ`($inp),$inp   # inp+=2
2192         add     $SZ*6($ctx),$G
2193         mov     $inp,%r12
2194         add     $SZ*7($ctx),$H
2195         cmp     $_end,$inp
2196
2197         mov     $A,$SZ*0($ctx)
2198         cmove   %rsp,%r12               # next block or stale data
2199         mov     $B,$SZ*1($ctx)
2200         mov     $C,$SZ*2($ctx)
2201         mov     $D,$SZ*3($ctx)
2202         mov     $E,$SZ*4($ctx)
2203         mov     $F,$SZ*5($ctx)
2204         mov     $G,$SZ*6($ctx)
2205         mov     $H,$SZ*7($ctx)
2206
2207         jbe     .Loop_avx2
2208         lea     (%rsp),$Tbl
2209
2210 .Ldone_avx2:
2211         lea     ($Tbl),%rsp
2212         mov     $_rsp,%rsi
2213 .cfi_def_cfa    %rsi,8
2214         vzeroupper
2215 ___
2216 $code.=<<___ if ($win64);
2217         movaps  16*$SZ+32(%rsp),%xmm6
2218         movaps  16*$SZ+48(%rsp),%xmm7
2219         movaps  16*$SZ+64(%rsp),%xmm8
2220         movaps  16*$SZ+80(%rsp),%xmm9
2221 ___
2222 $code.=<<___ if ($win64 && $SZ>4);
2223         movaps  16*$SZ+96(%rsp),%xmm10
2224         movaps  16*$SZ+112(%rsp),%xmm11
2225 ___
2226 $code.=<<___;
2227         mov     -48(%rsi),%r15
2228 .cfi_restore    %r15
2229         mov     -40(%rsi),%r14
2230 .cfi_restore    %r14
2231         mov     -32(%rsi),%r13
2232 .cfi_restore    %r13
2233         mov     -24(%rsi),%r12
2234 .cfi_restore    %r12
2235         mov     -16(%rsi),%rbp
2236 .cfi_restore    %rbp
2237         mov     -8(%rsi),%rbx
2238 .cfi_restore    %rbx
2239         lea     (%rsi),%rsp
2240 .cfi_def_cfa_register   %rsp
2241 .Lepilogue_avx2:
2242         ret
2243 .cfi_endproc
2244 .size   ${func}_avx2,.-${func}_avx2
2245 ___
2246 }}
2247 }}}}}
2248
2249 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
2250 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
2251 if ($win64) {
2252 $rec="%rcx";
2253 $frame="%rdx";
2254 $context="%r8";
2255 $disp="%r9";
2256
2257 $code.=<<___;
2258 .extern __imp_RtlVirtualUnwind
2259 .type   se_handler,\@abi-omnipotent
2260 .align  16
2261 se_handler:
2262         push    %rsi
2263         push    %rdi
2264         push    %rbx
2265         push    %rbp
2266         push    %r12
2267         push    %r13
2268         push    %r14
2269         push    %r15
2270         pushfq
2271         sub     \$64,%rsp
2272
2273         mov     120($context),%rax      # pull context->Rax
2274         mov     248($context),%rbx      # pull context->Rip
2275
2276         mov     8($disp),%rsi           # disp->ImageBase
2277         mov     56($disp),%r11          # disp->HanderlData
2278
2279         mov     0(%r11),%r10d           # HandlerData[0]
2280         lea     (%rsi,%r10),%r10        # prologue label
2281         cmp     %r10,%rbx               # context->Rip<prologue label
2282         jb      .Lin_prologue
2283
2284         mov     152($context),%rax      # pull context->Rsp
2285
2286         mov     4(%r11),%r10d           # HandlerData[1]
2287         lea     (%rsi,%r10),%r10        # epilogue label
2288         cmp     %r10,%rbx               # context->Rip>=epilogue label
2289         jae     .Lin_prologue
2290 ___
2291 $code.=<<___ if ($avx>1);
2292         lea     .Lavx2_shortcut(%rip),%r10
2293         cmp     %r10,%rbx               # context->Rip<avx2_shortcut
2294         jb      .Lnot_in_avx2
2295
2296         and     \$-256*$SZ,%rax
2297         add     \$`2*$SZ*($rounds-8)`,%rax
2298 .Lnot_in_avx2:
2299 ___
2300 $code.=<<___;
2301         mov     %rax,%rsi               # put aside Rsp
2302         mov     16*$SZ+3*8(%rax),%rax   # pull $_rsp
2303
2304         mov     -8(%rax),%rbx
2305         mov     -16(%rax),%rbp
2306         mov     -24(%rax),%r12
2307         mov     -32(%rax),%r13
2308         mov     -40(%rax),%r14
2309         mov     -48(%rax),%r15
2310         mov     %rbx,144($context)      # restore context->Rbx
2311         mov     %rbp,160($context)      # restore context->Rbp
2312         mov     %r12,216($context)      # restore context->R12
2313         mov     %r13,224($context)      # restore context->R13
2314         mov     %r14,232($context)      # restore context->R14
2315         mov     %r15,240($context)      # restore context->R15
2316
2317         lea     .Lepilogue(%rip),%r10
2318         cmp     %r10,%rbx
2319         jb      .Lin_prologue           # non-AVX code
2320
2321         lea     16*$SZ+4*8(%rsi),%rsi   # Xmm6- save area
2322         lea     512($context),%rdi      # &context.Xmm6
2323         mov     \$`$SZ==4?8:12`,%ecx
2324         .long   0xa548f3fc              # cld; rep movsq
2325
2326 .Lin_prologue:
2327         mov     8(%rax),%rdi
2328         mov     16(%rax),%rsi
2329         mov     %rax,152($context)      # restore context->Rsp
2330         mov     %rsi,168($context)      # restore context->Rsi
2331         mov     %rdi,176($context)      # restore context->Rdi
2332
2333         mov     40($disp),%rdi          # disp->ContextRecord
2334         mov     $context,%rsi           # context
2335         mov     \$154,%ecx              # sizeof(CONTEXT)
2336         .long   0xa548f3fc              # cld; rep movsq
2337
2338         mov     $disp,%rsi
2339         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
2340         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
2341         mov     0(%rsi),%r8             # arg3, disp->ControlPc
2342         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
2343         mov     40(%rsi),%r10           # disp->ContextRecord
2344         lea     56(%rsi),%r11           # &disp->HandlerData
2345         lea     24(%rsi),%r12           # &disp->EstablisherFrame
2346         mov     %r10,32(%rsp)           # arg5
2347         mov     %r11,40(%rsp)           # arg6
2348         mov     %r12,48(%rsp)           # arg7
2349         mov     %rcx,56(%rsp)           # arg8, (NULL)
2350         call    *__imp_RtlVirtualUnwind(%rip)
2351
2352         mov     \$1,%eax                # ExceptionContinueSearch
2353         add     \$64,%rsp
2354         popfq
2355         pop     %r15
2356         pop     %r14
2357         pop     %r13
2358         pop     %r12
2359         pop     %rbp
2360         pop     %rbx
2361         pop     %rdi
2362         pop     %rsi
2363         ret
2364 .size   se_handler,.-se_handler
2365 ___
2366
2367 $code.=<<___ if ($SZ==4 && $shaext);
2368 .type   shaext_handler,\@abi-omnipotent
2369 .align  16
2370 shaext_handler:
2371         push    %rsi
2372         push    %rdi
2373         push    %rbx
2374         push    %rbp
2375         push    %r12
2376         push    %r13
2377         push    %r14
2378         push    %r15
2379         pushfq
2380         sub     \$64,%rsp
2381
2382         mov     120($context),%rax      # pull context->Rax
2383         mov     248($context),%rbx      # pull context->Rip
2384
2385         lea     .Lprologue_shaext(%rip),%r10
2386         cmp     %r10,%rbx               # context->Rip<.Lprologue
2387         jb      .Lin_prologue
2388
2389         lea     .Lepilogue_shaext(%rip),%r10
2390         cmp     %r10,%rbx               # context->Rip>=.Lepilogue
2391         jae     .Lin_prologue
2392
2393         lea     -8-5*16(%rax),%rsi
2394         lea     512($context),%rdi      # &context.Xmm6
2395         mov     \$10,%ecx
2396         .long   0xa548f3fc              # cld; rep movsq
2397
2398         jmp     .Lin_prologue
2399 .size   shaext_handler,.-shaext_handler
2400 ___
2401
2402 $code.=<<___;
2403 .section        .pdata
2404 .align  4
2405         .rva    .LSEH_begin_$func
2406         .rva    .LSEH_end_$func
2407         .rva    .LSEH_info_$func
2408 ___
2409 $code.=<<___ if ($SZ==4 && $shaext);
2410         .rva    .LSEH_begin_${func}_shaext
2411         .rva    .LSEH_end_${func}_shaext
2412         .rva    .LSEH_info_${func}_shaext
2413 ___
2414 $code.=<<___ if ($SZ==4);
2415         .rva    .LSEH_begin_${func}_ssse3
2416         .rva    .LSEH_end_${func}_ssse3
2417         .rva    .LSEH_info_${func}_ssse3
2418 ___
2419 $code.=<<___ if ($avx && $SZ==8);
2420         .rva    .LSEH_begin_${func}_xop
2421         .rva    .LSEH_end_${func}_xop
2422         .rva    .LSEH_info_${func}_xop
2423 ___
2424 $code.=<<___ if ($avx);
2425         .rva    .LSEH_begin_${func}_avx
2426         .rva    .LSEH_end_${func}_avx
2427         .rva    .LSEH_info_${func}_avx
2428 ___
2429 $code.=<<___ if ($avx>1);
2430         .rva    .LSEH_begin_${func}_avx2
2431         .rva    .LSEH_end_${func}_avx2
2432         .rva    .LSEH_info_${func}_avx2
2433 ___
2434 $code.=<<___;
2435 .section        .xdata
2436 .align  8
2437 .LSEH_info_$func:
2438         .byte   9,0,0,0
2439         .rva    se_handler
2440         .rva    .Lprologue,.Lepilogue                   # HandlerData[]
2441 ___
2442 $code.=<<___ if ($SZ==4 && $shaext);
2443 .LSEH_info_${func}_shaext:
2444         .byte   9,0,0,0
2445         .rva    shaext_handler
2446 ___
2447 $code.=<<___ if ($SZ==4);
2448 .LSEH_info_${func}_ssse3:
2449         .byte   9,0,0,0
2450         .rva    se_handler
2451         .rva    .Lprologue_ssse3,.Lepilogue_ssse3       # HandlerData[]
2452 ___
2453 $code.=<<___ if ($avx && $SZ==8);
2454 .LSEH_info_${func}_xop:
2455         .byte   9,0,0,0
2456         .rva    se_handler
2457         .rva    .Lprologue_xop,.Lepilogue_xop           # HandlerData[]
2458 ___
2459 $code.=<<___ if ($avx);
2460 .LSEH_info_${func}_avx:
2461         .byte   9,0,0,0
2462         .rva    se_handler
2463         .rva    .Lprologue_avx,.Lepilogue_avx           # HandlerData[]
2464 ___
2465 $code.=<<___ if ($avx>1);
2466 .LSEH_info_${func}_avx2:
2467         .byte   9,0,0,0
2468         .rva    se_handler
2469         .rva    .Lprologue_avx2,.Lepilogue_avx2         # HandlerData[]
2470 ___
2471 }
2472
2473 sub sha256op38 {
2474     my $instr = shift;
2475     my %opcodelet = (
2476                 "sha256rnds2" => 0xcb,
2477                 "sha256msg1"  => 0xcc,
2478                 "sha256msg2"  => 0xcd   );
2479
2480     if (defined($opcodelet{$instr}) && @_[0] =~ /%xmm([0-7]),\s*%xmm([0-7])/) {
2481       my @opcode=(0x0f,0x38);
2482         push @opcode,$opcodelet{$instr};
2483         push @opcode,0xc0|($1&7)|(($2&7)<<3);           # ModR/M
2484         return ".byte\t".join(',',@opcode);
2485     } else {
2486         return $instr."\t".@_[0];
2487     }
2488 }
2489
2490 foreach (split("\n",$code)) {
2491         s/\`([^\`]*)\`/eval $1/geo;
2492
2493         s/\b(sha256[^\s]*)\s+(.*)/sha256op38($1,$2)/geo;
2494
2495         print $_,"\n";
2496 }
2497 close STDOUT;