mpi/ec: fix when 'unsigned long' is 32-bit but limb size is 64-bit
[libgcrypt.git] / cipher / sha256-ssse3-amd64.S
1 /*
2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3 ; Copyright (c) 2012, Intel Corporation
4 ;
5 ; All rights reserved.
6 ;
7 ; Redistribution and use in source and binary forms, with or without
8 ; modification, are permitted provided that the following conditions are
9 ; met:
10 ;
11 ; * Redistributions of source code must retain the above copyright
12 ;   notice, this list of conditions and the following disclaimer.
13 ;
14 ; * Redistributions in binary form must reproduce the above copyright
15 ;   notice, this list of conditions and the following disclaimer in the
16 ;   documentation and/or other materials provided with the
17 ;   distribution.
18 ;
19 ; * Neither the name of the Intel Corporation nor the names of its
20 ;   contributors may be used to endorse or promote products derived from
21 ;   this software without specific prior written permission.
22 ;
23 ;
24 ; THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY
25 ; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 ; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
27 ; PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR
28 ; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
29 ; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
30 ; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
31 ; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32 ; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33 ; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 ; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
36 ;
37 ; This code is described in an Intel White-Paper:
38 ; "Fast SHA-256 Implementations on Intel Architecture Processors"
39 ;
40 ; To find it, surf to http://www.intel.com/p/en_US/embedded
41 ; and search for that title.
42 ; The paper is expected to be released roughly at the end of April, 2012
43 ;
44 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
45 ; This code schedules 1 blocks at a time, with 4 lanes per block
46 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
47 */
48 /*
49  * Conversion to GAS assembly and integration to libgcrypt
50  *  by Jussi Kivilinna <jussi.kivilinna@iki.fi>
51  *
52  * Note: original implementation was named as SHA256-SSE4. However, only SSSE3
53  *       is required.
54  */
55
56 #ifdef __x86_64
57 #include <config.h>
58 #if (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
59      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS)) && \
60     defined(HAVE_INTEL_SYNTAX_PLATFORM_AS) && \
61     defined(HAVE_GCC_INLINE_ASM_SSSE3) && defined(USE_SHA256)
62
63 #ifdef __PIC__
64 #  define ADD_RIP +rip
65 #else
66 #  define ADD_RIP
67 #endif
68
69 #ifdef HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS
70 # define ELF(...) __VA_ARGS__
71 #else
72 # define ELF(...) /*_*/
73 #endif
74
75 .intel_syntax noprefix
76
77 #define MOVDQ movdqu /* assume buffers not aligned */
78
79 /*;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Define Macros*/
80
81 /* addm [mem], reg
82  * Add reg to mem using reg-mem add and store */
83 .macro addm p1 p2
84         add     \p2, \p1
85         mov     \p1, \p2
86 .endm
87
88 /*;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
89
90 /* COPY_XMM_AND_BSWAP xmm, [mem], byte_flip_mask
91  * Load xmm with mem and byte swap each dword */
92 .macro COPY_XMM_AND_BSWAP p1 p2 p3
93         MOVDQ \p1, \p2
94         pshufb \p1, \p3
95 .endm
96
97 /*;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
98
99 X0 = xmm4
100 X1 = xmm5
101 X2 = xmm6
102 X3 = xmm7
103
104 XTMP0 = xmm0
105 XTMP1 = xmm1
106 XTMP2 = xmm2
107 XTMP3 = xmm3
108 XTMP4 = xmm8
109 XFER  = xmm9
110
111 SHUF_00BA = xmm10 /* shuffle xBxA -> 00BA */
112 SHUF_DC00 = xmm11 /* shuffle xDxC -> DC00 */
113 BYTE_FLIP_MASK = xmm12
114
115 NUM_BLKS = rdx  /* 3rd arg */
116 CTX = rsi       /* 2nd arg */
117 INP = rdi       /* 1st arg */
118
119 SRND = rdi      /* clobbers INP */
120 c = ecx
121 d = r8d
122 e = edx
123
124 TBL = rbp
125 a = eax
126 b = ebx
127
128 f = r9d
129 g = r10d
130 h = r11d
131
132 y0 = r13d
133 y1 = r14d
134 y2 = r15d
135
136
137
138 #define _INP_END_SIZE   8
139 #define _INP_SIZE       8
140 #define _XFER_SIZE      8
141 #define _XMM_SAVE_SIZE  0
142 /* STACK_SIZE plus pushes must be an odd multiple of 8 */
143 #define _ALIGN_SIZE     8
144
145 #define _INP_END        0
146 #define _INP            (_INP_END  + _INP_END_SIZE)
147 #define _XFER           (_INP      + _INP_SIZE)
148 #define _XMM_SAVE       (_XFER     + _XFER_SIZE + _ALIGN_SIZE)
149 #define STACK_SIZE      (_XMM_SAVE + _XMM_SAVE_SIZE)
150
151 /* rotate_Xs
152  * Rotate values of symbols X0...X3 */
153 .macro rotate_Xs
154 X_ = X0
155 X0 = X1
156 X1 = X2
157 X2 = X3
158 X3 = X_
159 .endm
160
161 /* ROTATE_ARGS
162  * Rotate values of symbols a...h */
163 .macro ROTATE_ARGS
164 TMP_ = h
165 h = g
166 g = f
167 f = e
168 e = d
169 d = c
170 c = b
171 b = a
172 a = TMP_
173 .endm
174
175 .macro FOUR_ROUNDS_AND_SCHED
176                 /* compute s0 four at a time and s1 two at a time
177                  * compute W[-16] + W[-7] 4 at a time */
178                 movdqa  XTMP0, X3
179         mov     y0, e           /* y0 = e */
180         ror     y0, (25-11)     /* y0 = e >> (25-11) */
181         mov     y1, a           /* y1 = a */
182                 palignr XTMP0, X2, 4    /* XTMP0 = W[-7] */
183         ror     y1, (22-13)     /* y1 = a >> (22-13) */
184         xor     y0, e           /* y0 = e ^ (e >> (25-11)) */
185         mov     y2, f           /* y2 = f */
186         ror     y0, (11-6)      /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
187                 movdqa  XTMP1, X1
188         xor     y1, a           /* y1 = a ^ (a >> (22-13) */
189         xor     y2, g           /* y2 = f^g */
190                 paddd   XTMP0, X0       /* XTMP0 = W[-7] + W[-16] */
191         xor     y0, e           /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
192         and     y2, e           /* y2 = (f^g)&e */
193         ror     y1, (13-2)      /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
194                 /* compute s0 */
195                 palignr XTMP1, X0, 4    /* XTMP1 = W[-15] */
196         xor     y1, a           /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
197         ror     y0, 6           /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
198         xor     y2, g           /* y2 = CH = ((f^g)&e)^g */
199                 movdqa  XTMP2, XTMP1    /* XTMP2 = W[-15] */
200         ror     y1, 2           /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
201         add     y2, y0          /* y2 = S1 + CH */
202         add     y2, [rsp + _XFER + 0*4] /* y2 = k + w + S1 + CH */
203                 movdqa  XTMP3, XTMP1    /* XTMP3 = W[-15] */
204         mov     y0, a           /* y0 = a */
205         add     h, y2           /* h = h + S1 + CH + k + w */
206         mov     y2, a           /* y2 = a */
207                 pslld   XTMP1, (32-7)
208         or      y0, c           /* y0 = a|c */
209         add     d, h            /* d = d + h + S1 + CH + k + w */
210         and     y2, c           /* y2 = a&c */
211                 psrld   XTMP2, 7
212         and     y0, b           /* y0 = (a|c)&b */
213         add     h, y1           /* h = h + S1 + CH + k + w + S0 */
214                 por     XTMP1, XTMP2    /* XTMP1 = W[-15] ror 7 */
215         or      y0, y2          /* y0 = MAJ = (a|c)&b)|(a&c) */
216         lea     h, [h + y0]     /* h = h + S1 + CH + k + w + S0 + MAJ */
217
218 ROTATE_ARGS
219                 movdqa  XTMP2, XTMP3    /* XTMP2 = W[-15] */
220         mov     y0, e           /* y0 = e */
221         mov     y1, a           /* y1 = a */
222                 movdqa  XTMP4, XTMP3    /* XTMP4 = W[-15] */
223         ror     y0, (25-11)     /* y0 = e >> (25-11) */
224         xor     y0, e           /* y0 = e ^ (e >> (25-11)) */
225         mov     y2, f           /* y2 = f */
226         ror     y1, (22-13)     /* y1 = a >> (22-13) */
227                 pslld   XTMP3, (32-18)
228         xor     y1, a           /* y1 = a ^ (a >> (22-13) */
229         ror     y0, (11-6)      /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
230         xor     y2, g           /* y2 = f^g */
231                 psrld   XTMP2, 18
232         ror     y1, (13-2)      /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
233         xor     y0, e           /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
234         and     y2, e           /* y2 = (f^g)&e */
235         ror     y0, 6           /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
236                 pxor    XTMP1, XTMP3
237         xor     y1, a           /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
238         xor     y2, g           /* y2 = CH = ((f^g)&e)^g */
239                 psrld   XTMP4, 3        /* XTMP4 = W[-15] >> 3 */
240         add     y2, y0          /* y2 = S1 + CH */
241         add     y2, [rsp + _XFER + 1*4] /* y2 = k + w + S1 + CH */
242         ror     y1, 2           /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
243                 pxor    XTMP1, XTMP2    /* XTMP1 = W[-15] ror 7 ^ W[-15] ror 18 */
244         mov     y0, a           /* y0 = a */
245         add     h, y2           /* h = h + S1 + CH + k + w */
246         mov     y2, a           /* y2 = a */
247                 pxor    XTMP1, XTMP4    /* XTMP1 = s0 */
248         or      y0, c           /* y0 = a|c */
249         add     d, h            /* d = d + h + S1 + CH + k + w */
250         and     y2, c           /* y2 = a&c */
251                 /* compute low s1 */
252                 pshufd  XTMP2, X3, 0b11111010   /* XTMP2 = W[-2] {BBAA} */
253         and     y0, b           /* y0 = (a|c)&b */
254         add     h, y1           /* h = h + S1 + CH + k + w + S0 */
255                 paddd   XTMP0, XTMP1    /* XTMP0 = W[-16] + W[-7] + s0 */
256         or      y0, y2          /* y0 = MAJ = (a|c)&b)|(a&c) */
257         lea     h, [h + y0]     /* h = h + S1 + CH + k + w + S0 + MAJ */
258
259 ROTATE_ARGS
260                 movdqa  XTMP3, XTMP2    /* XTMP3 = W[-2] {BBAA} */
261         mov     y0, e           /* y0 = e */
262         mov     y1, a           /* y1 = a */
263         ror     y0, (25-11)     /* y0 = e >> (25-11) */
264                 movdqa  XTMP4, XTMP2    /* XTMP4 = W[-2] {BBAA} */
265         xor     y0, e           /* y0 = e ^ (e >> (25-11)) */
266         ror     y1, (22-13)     /* y1 = a >> (22-13) */
267         mov     y2, f           /* y2 = f */
268         xor     y1, a           /* y1 = a ^ (a >> (22-13) */
269         ror     y0, (11-6)      /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
270                 psrlq   XTMP2, 17       /* XTMP2 = W[-2] ror 17 {xBxA} */
271         xor     y2, g           /* y2 = f^g */
272                 psrlq   XTMP3, 19       /* XTMP3 = W[-2] ror 19 {xBxA} */
273         xor     y0, e           /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
274         and     y2, e           /* y2 = (f^g)&e */
275                 psrld   XTMP4, 10       /* XTMP4 = W[-2] >> 10 {BBAA} */
276         ror     y1, (13-2)      /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
277         xor     y1, a           /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
278         xor     y2, g           /* y2 = CH = ((f^g)&e)^g */
279         ror     y0, 6           /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
280                 pxor    XTMP2, XTMP3
281         add     y2, y0          /* y2 = S1 + CH */
282         ror     y1, 2           /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
283         add     y2, [rsp + _XFER + 2*4] /* y2 = k + w + S1 + CH */
284                 pxor    XTMP4, XTMP2    /* XTMP4 = s1 {xBxA} */
285         mov     y0, a           /* y0 = a */
286         add     h, y2           /* h = h + S1 + CH + k + w */
287         mov     y2, a           /* y2 = a */
288                 pshufb  XTMP4, SHUF_00BA        /* XTMP4 = s1 {00BA} */
289         or      y0, c           /* y0 = a|c */
290         add     d, h            /* d = d + h + S1 + CH + k + w */
291         and     y2, c           /* y2 = a&c */
292                 paddd   XTMP0, XTMP4    /* XTMP0 = {..., ..., W[1], W[0]} */
293         and     y0, b           /* y0 = (a|c)&b */
294         add     h, y1           /* h = h + S1 + CH + k + w + S0 */
295                 /* compute high s1 */
296                 pshufd  XTMP2, XTMP0, 0b01010000 /* XTMP2 = W[-2] {DDCC} */
297         or      y0, y2          /* y0 = MAJ = (a|c)&b)|(a&c) */
298         lea     h, [h + y0]     /* h = h + S1 + CH + k + w + S0 + MAJ */
299
300 ROTATE_ARGS
301                 movdqa  XTMP3, XTMP2    /* XTMP3 = W[-2] {DDCC} */
302         mov     y0, e           /* y0 = e */
303         ror     y0, (25-11)     /* y0 = e >> (25-11) */
304         mov     y1, a           /* y1 = a */
305                 movdqa  X0,    XTMP2    /* X0    = W[-2] {DDCC} */
306         ror     y1, (22-13)     /* y1 = a >> (22-13) */
307         xor     y0, e           /* y0 = e ^ (e >> (25-11)) */
308         mov     y2, f           /* y2 = f */
309         ror     y0, (11-6)      /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
310                 psrlq   XTMP2, 17       /* XTMP2 = W[-2] ror 17 {xDxC} */
311         xor     y1, a           /* y1 = a ^ (a >> (22-13) */
312         xor     y2, g           /* y2 = f^g */
313                 psrlq   XTMP3, 19       /* XTMP3 = W[-2] ror 19 {xDxC} */
314         xor     y0, e           /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
315         and     y2, e           /* y2 = (f^g)&e */
316         ror     y1, (13-2)      /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
317                 psrld   X0,    10       /* X0 = W[-2] >> 10 {DDCC} */
318         xor     y1, a           /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
319         ror     y0, 6           /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
320         xor     y2, g           /* y2 = CH = ((f^g)&e)^g */
321                 pxor    XTMP2, XTMP3
322         ror     y1, 2           /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
323         add     y2, y0          /* y2 = S1 + CH */
324         add     y2, [rsp + _XFER + 3*4] /* y2 = k + w + S1 + CH */
325                 pxor    X0, XTMP2       /* X0 = s1 {xDxC} */
326         mov     y0, a           /* y0 = a */
327         add     h, y2           /* h = h + S1 + CH + k + w */
328         mov     y2, a           /* y2 = a */
329                 pshufb  X0, SHUF_DC00   /* X0 = s1 {DC00} */
330         or      y0, c           /* y0 = a|c */
331         add     d, h            /* d = d + h + S1 + CH + k + w */
332         and     y2, c           /* y2 = a&c */
333                 paddd   X0, XTMP0       /* X0 = {W[3], W[2], W[1], W[0]} */
334         and     y0, b           /* y0 = (a|c)&b */
335         add     h, y1           /* h = h + S1 + CH + k + w + S0 */
336         or      y0, y2          /* y0 = MAJ = (a|c)&b)|(a&c) */
337         lea     h, [h + y0]     /* h = h + S1 + CH + k + w + S0 + MAJ */
338
339 ROTATE_ARGS
340 rotate_Xs
341 .endm
342
343 /* input is [rsp + _XFER + %1 * 4] */
344 .macro DO_ROUND i1
345         mov     y0, e           /* y0 = e */
346         ror     y0, (25-11)     /* y0 = e >> (25-11) */
347         mov     y1, a           /* y1 = a */
348         xor     y0, e           /* y0 = e ^ (e >> (25-11)) */
349         ror     y1, (22-13)     /* y1 = a >> (22-13) */
350         mov     y2, f           /* y2 = f */
351         xor     y1, a           /* y1 = a ^ (a >> (22-13) */
352         ror     y0, (11-6)      /* y0 = (e >> (11-6)) ^ (e >> (25-6)) */
353         xor     y2, g           /* y2 = f^g */
354         xor     y0, e           /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6)) */
355         ror     y1, (13-2)      /* y1 = (a >> (13-2)) ^ (a >> (22-2)) */
356         and     y2, e           /* y2 = (f^g)&e */
357         xor     y1, a           /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2)) */
358         ror     y0, 6           /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25) */
359         xor     y2, g           /* y2 = CH = ((f^g)&e)^g */
360         add     y2, y0          /* y2 = S1 + CH */
361         ror     y1, 2           /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22) */
362         add     y2, [rsp + _XFER + \i1 * 4]     /* y2 = k + w + S1 + CH */
363         mov     y0, a           /* y0 = a */
364         add     h, y2           /* h = h + S1 + CH + k + w */
365         mov     y2, a           /* y2 = a */
366         or      y0, c           /* y0 = a|c */
367         add     d, h            /* d = d + h + S1 + CH + k + w */
368         and     y2, c           /* y2 = a&c */
369         and     y0, b           /* y0 = (a|c)&b */
370         add     h, y1           /* h = h + S1 + CH + k + w + S0 */
371         or      y0, y2          /* y0 = MAJ = (a|c)&b)|(a&c) */
372         lea     h, [h + y0]     /* h = h + S1 + CH + k + w + S0 + MAJ */
373         ROTATE_ARGS
374 .endm
375
376 /*
377 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
378 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
379 ;; void sha256_sse4(void *input_data, UINT32 digest[8], UINT64 num_blks)
380 ;; arg 1 : pointer to input data
381 ;; arg 2 : pointer to digest
382 ;; arg 3 : Num blocks
383 */
384 .text
385 .globl _gcry_sha256_transform_amd64_ssse3
386 ELF(.type  _gcry_sha256_transform_amd64_ssse3,@function;)
387 .align 16
388 _gcry_sha256_transform_amd64_ssse3:
389         push    rbx
390         push    rbp
391         push    r13
392         push    r14
393         push    r15
394
395         sub     rsp, STACK_SIZE
396
397         shl     NUM_BLKS, 6     /* convert to bytes */
398         jz      .Ldone_hash
399         add     NUM_BLKS, INP   /* pointer to end of data */
400         mov     [rsp + _INP_END], NUM_BLKS
401
402         /* load initial digest */
403         mov     a,[4*0 + CTX]
404         mov     b,[4*1 + CTX]
405         mov     c,[4*2 + CTX]
406         mov     d,[4*3 + CTX]
407         mov     e,[4*4 + CTX]
408         mov     f,[4*5 + CTX]
409         mov     g,[4*6 + CTX]
410         mov     h,[4*7 + CTX]
411
412         movdqa  BYTE_FLIP_MASK, [.LPSHUFFLE_BYTE_FLIP_MASK ADD_RIP]
413         movdqa  SHUF_00BA, [.L_SHUF_00BA ADD_RIP]
414         movdqa  SHUF_DC00, [.L_SHUF_DC00 ADD_RIP]
415
416 .Loop0:
417         lea     TBL, [.LK256 ADD_RIP]
418
419         /* byte swap first 16 dwords */
420         COPY_XMM_AND_BSWAP      X0, [INP + 0*16], BYTE_FLIP_MASK
421         COPY_XMM_AND_BSWAP      X1, [INP + 1*16], BYTE_FLIP_MASK
422         COPY_XMM_AND_BSWAP      X2, [INP + 2*16], BYTE_FLIP_MASK
423         COPY_XMM_AND_BSWAP      X3, [INP + 3*16], BYTE_FLIP_MASK
424
425         mov     [rsp + _INP], INP
426
427         /* schedule 48 input dwords, by doing 3 rounds of 16 each */
428         mov     SRND, 3
429 .align 16
430 .Loop1:
431         movdqa  XFER, [TBL + 0*16]
432         paddd   XFER, X0
433         movdqa  [rsp + _XFER], XFER
434         FOUR_ROUNDS_AND_SCHED
435
436         movdqa  XFER, [TBL + 1*16]
437         paddd   XFER, X0
438         movdqa  [rsp + _XFER], XFER
439         FOUR_ROUNDS_AND_SCHED
440
441         movdqa  XFER, [TBL + 2*16]
442         paddd   XFER, X0
443         movdqa  [rsp + _XFER], XFER
444         FOUR_ROUNDS_AND_SCHED
445
446         movdqa  XFER, [TBL + 3*16]
447         paddd   XFER, X0
448         movdqa  [rsp + _XFER], XFER
449         add     TBL, 4*16
450         FOUR_ROUNDS_AND_SCHED
451
452         sub     SRND, 1
453         jne     .Loop1
454
455         mov     SRND, 2
456 .Loop2:
457         paddd   X0, [TBL + 0*16]
458         movdqa  [rsp + _XFER], X0
459         DO_ROUND        0
460         DO_ROUND        1
461         DO_ROUND        2
462         DO_ROUND        3
463         paddd   X1, [TBL + 1*16]
464         movdqa  [rsp + _XFER], X1
465         add     TBL, 2*16
466         DO_ROUND        0
467         DO_ROUND        1
468         DO_ROUND        2
469         DO_ROUND        3
470
471         movdqa  X0, X2
472         movdqa  X1, X3
473
474         sub     SRND, 1
475         jne     .Loop2
476
477         addm    [4*0 + CTX],a
478         addm    [4*1 + CTX],b
479         addm    [4*2 + CTX],c
480         addm    [4*3 + CTX],d
481         addm    [4*4 + CTX],e
482         addm    [4*5 + CTX],f
483         addm    [4*6 + CTX],g
484         addm    [4*7 + CTX],h
485
486         mov     INP, [rsp + _INP]
487         add     INP, 64
488         cmp     INP, [rsp + _INP_END]
489         jne     .Loop0
490
491         pxor    xmm0, xmm0
492         pxor    xmm1, xmm1
493         pxor    xmm2, xmm2
494         pxor    xmm3, xmm3
495         pxor    xmm4, xmm4
496         pxor    xmm5, xmm5
497         pxor    xmm6, xmm6
498         pxor    xmm7, xmm7
499         pxor    xmm8, xmm8
500         pxor    xmm9, xmm9
501         pxor    xmm10, xmm10
502         pxor    xmm11, xmm11
503         pxor    xmm12, xmm12
504
505 .Ldone_hash:
506         add     rsp, STACK_SIZE
507
508         pop     r15
509         pop     r14
510         pop     r13
511         pop     rbp
512         pop     rbx
513
514         mov     eax, STACK_SIZE + 5*8
515
516         ret
517
518
519 .align 16
520 .LK256:
521         .long   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
522         .long   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
523         .long   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
524         .long   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
525         .long   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
526         .long   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
527         .long   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
528         .long   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
529         .long   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
530         .long   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
531         .long   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
532         .long   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
533         .long   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
534         .long   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
535         .long   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
536         .long   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
537
538 .LPSHUFFLE_BYTE_FLIP_MASK: .octa 0x0c0d0e0f08090a0b0405060700010203
539
540 /* shuffle xBxA -> 00BA */
541 .L_SHUF_00BA:              .octa 0xFFFFFFFFFFFFFFFF0b0a090803020100
542
543 /* shuffle xDxC -> DC00 */
544 .L_SHUF_DC00:              .octa 0x0b0a090803020100FFFFFFFFFFFFFFFF
545
546 #endif
547 #endif