git.ozlabs.org Git - ccan/blob - ccan/crypto/sha256/benchmarks/sha256_sse4.asm

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