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