LXR linux/arch/x86/crypto/sha256-avx-asm.S

   1########################################################################
   2# Implement fast SHA-256 with AVX1 instructions. (x86_64)
   3#
   4# Copyright (C) 2013 Intel Corporation.
   5#
   6# Authors:
   7#     James Guilford <james.guilford@intel.com>
   8#     Kirk Yap <kirk.s.yap@intel.com>
   9#     Tim Chen <tim.c.chen@linux.intel.com>
  10#
  11# This software is available to you under a choice of one of two
  12# licenses.  You may choose to be licensed under the terms of the GNU
  13# General Public License (GPL) Version 2, available from the file
  14# COPYING in the main directory of this source tree, or the
  15# OpenIB.org BSD license below:
  16#
  17#     Redistribution and use in source and binary forms, with or
  18#     without modification, are permitted provided that the following
  19#     conditions are met:
  20#
  21#      - Redistributions of source code must retain the above
  22#        copyright notice, this list of conditions and the following
  23#        disclaimer.
  24#
  25#      - Redistributions in binary form must reproduce the above
  26#        copyright notice, this list of conditions and the following
  27#        disclaimer in the documentation and/or other materials
  28#        provided with the distribution.
  29#
  30# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  31# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  32# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  33# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  34# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  35# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  36# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  37# SOFTWARE.
  38########################################################################
  39#
  40# This code is described in an Intel White-Paper:
  41# "Fast SHA-256 Implementations on Intel Architecture Processors"
  42#
  43# To find it, surf to http://www.intel.com/p/en_US/embedded
  44# and search for that title.
  45#
  46########################################################################
  47# This code schedules 1 block at a time, with 4 lanes per block
  48########################################################################
  49
  50#ifdef CONFIG_AS_AVX
  51#include <linux/linkage.h>
  52
  53## assume buffers not aligned
  54#define    VMOVDQ vmovdqu
  55
  56################################ Define Macros
  57
  58# addm [mem], reg
  59# Add reg to mem using reg-mem add and store
  60.macro addm p1 p2
  61        add     \p1, \p2
  62        mov     \p2, \p1
  63.endm
  64
  65
  66.macro MY_ROR p1 p2
  67        shld    $(32-(\p1)), \p2, \p2
  68.endm
  69
  70################################
  71
  72# COPY_XMM_AND_BSWAP xmm, [mem], byte_flip_mask
  73# Load xmm with mem and byte swap each dword
  74.macro COPY_XMM_AND_BSWAP p1 p2 p3
  75        VMOVDQ \p2, \p1
  76        vpshufb \p3, \p1, \p1
  77.endm
  78
  79################################
  80
  81X0 = %xmm4
  82X1 = %xmm5
  83X2 = %xmm6
  84X3 = %xmm7
  85
  86XTMP0 = %xmm0
  87XTMP1 = %xmm1
  88XTMP2 = %xmm2
  89XTMP3 = %xmm3
  90XTMP4 = %xmm8
  91XFER = %xmm9
  92XTMP5 = %xmm11
  93
  94SHUF_00BA = %xmm10      # shuffle xBxA -> 00BA
  95SHUF_DC00 = %xmm12      # shuffle xDxC -> DC00
  96BYTE_FLIP_MASK = %xmm13
  97
  98NUM_BLKS = %rdx   # 3rd arg
  99INP = %rsi        # 2nd arg
 100CTX = %rdi        # 1st arg
 101
 102SRND = %rsi       # clobbers INP
 103c = %ecx
 104d = %r8d
 105e = %edx
 106TBL = %r12
 107a = %eax
 108b = %ebx
 109
 110f = %r9d
 111g = %r10d
 112h = %r11d
 113
 114y0 = %r13d
 115y1 = %r14d
 116y2 = %r15d
 117
 118
 119_INP_END_SIZE = 8
 120_INP_SIZE = 8
 121_XFER_SIZE = 16
 122_XMM_SAVE_SIZE = 0
 123
 124_INP_END = 0
 125_INP            = _INP_END  + _INP_END_SIZE
 126_XFER           = _INP      + _INP_SIZE
 127_XMM_SAVE       = _XFER     + _XFER_SIZE
 128STACK_SIZE      = _XMM_SAVE + _XMM_SAVE_SIZE
 129
 130# rotate_Xs
 131# Rotate values of symbols X0...X3
 132.macro rotate_Xs
 133X_ = X0
 134X0 = X1
 135X1 = X2
 136X2 = X3
 137X3 = X_
 138.endm
 139
 140# ROTATE_ARGS
 141# Rotate values of symbols a...h
 142.macro ROTATE_ARGS
 143TMP_ = h
 144h = g
 145g = f
 146f = e
 147e = d
 148d = c
 149c = b
 150b = a
 151a = TMP_
 152.endm
 153
 154.macro FOUR_ROUNDS_AND_SCHED
 155        ## compute s0 four at a time and s1 two at a time
 156        ## compute W[-16] + W[-7] 4 at a time
 157
 158        mov     e, y0                   # y0 = e
 159        MY_ROR  (25-11), y0             # y0 = e >> (25-11)
 160        mov     a, y1                   # y1 = a
 161        vpalignr $4, X2, X3, XTMP0      # XTMP0 = W[-7]
 162        MY_ROR  (22-13), y1             # y1 = a >> (22-13)
 163        xor     e, y0                   # y0 = e ^ (e >> (25-11))
 164        mov     f, y2                   # y2 = f
 165        MY_ROR  (11-6), y0              # y0 = (e >> (11-6)) ^ (e >> (25-6))
 166        xor     a, y1                   # y1 = a ^ (a >> (22-13)
 167        xor     g, y2                   # y2 = f^g
 168        vpaddd  X0, XTMP0, XTMP0        # XTMP0 = W[-7] + W[-16]
 169        xor     e, y0                   # y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
 170        and     e, y2                   # y2 = (f^g)&e
 171        MY_ROR  (13-2), y1              # y1 = (a >> (13-2)) ^ (a >> (22-2))
 172        ## compute s0
 173        vpalignr $4, X0, X1, XTMP1      # XTMP1 = W[-15]
 174        xor     a, y1                   # y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
 175        MY_ROR  6, y0                   # y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
 176        xor     g, y2                   # y2 = CH = ((f^g)&e)^g
 177        MY_ROR  2, y1                   # y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
 178        add     y0, y2                  # y2 = S1 + CH
 179        add     _XFER(%rsp), y2         # y2 = k + w + S1 + CH
 180        mov     a, y0                   # y0 = a
 181        add     y2, h                   # h = h + S1 + CH + k + w
 182        mov     a, y2                   # y2 = a
 183        vpsrld  $7, XTMP1, XTMP2
 184        or      c, y0                   # y0 = a|c
 185        add     h, d                    # d = d + h + S1 + CH + k + w
 186        and     c, y2                   # y2 = a&c
 187        vpslld  $(32-7), XTMP1, XTMP3
 188        and     b, y0                   # y0 = (a|c)&b
 189        add     y1, h                   # h = h + S1 + CH + k + w + S0
 190        vpor    XTMP2, XTMP3, XTMP3     # XTMP1 = W[-15] MY_ROR 7
 191        or      y2, y0                  # y0 = MAJ = (a|c)&b)|(a&c)
 192        add     y0, h                   # h = h + S1 + CH + k + w + S0 + MAJ
 193        ROTATE_ARGS
 194        mov     e, y0                   # y0 = e
 195        mov     a, y1                   # y1 = a
 196        MY_ROR  (25-11), y0             # y0 = e >> (25-11)
 197        xor     e, y0                   # y0 = e ^ (e >> (25-11))
 198        mov     f, y2                   # y2 = f
 199        MY_ROR  (22-13), y1             # y1 = a >> (22-13)
 200        vpsrld  $18, XTMP1, XTMP2       #
 201        xor     a, y1                   # y1 = a ^ (a >> (22-13)
 202        MY_ROR  (11-6), y0              # y0 = (e >> (11-6)) ^ (e >> (25-6))
 203        xor     g, y2                   # y2 = f^g
 204        vpsrld  $3, XTMP1, XTMP4        # XTMP4 = W[-15] >> 3
 205        MY_ROR  (13-2), y1              # y1 = (a >> (13-2)) ^ (a >> (22-2))
 206        xor     e, y0                   # y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
 207        and     e, y2                   # y2 = (f^g)&e
 208        MY_ROR  6, y0                   # y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
 209        vpslld  $(32-18), XTMP1, XTMP1
 210        xor     a, y1                   # y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
 211        xor     g, y2                   # y2 = CH = ((f^g)&e)^g
 212        vpxor   XTMP1, XTMP3, XTMP3     #
 213        add     y0, y2                  # y2 = S1 + CH
 214        add     (1*4 + _XFER)(%rsp), y2 # y2 = k + w + S1 + CH
 215        MY_ROR  2, y1                   # y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
 216        vpxor   XTMP2, XTMP3, XTMP3     # XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR
 217        mov     a, y0                   # y0 = a
 218        add     y2, h                   # h = h + S1 + CH + k + w
 219        mov     a, y2                   # y2 = a
 220        vpxor   XTMP4, XTMP3, XTMP1     # XTMP1 = s0
 221        or      c, y0                   # y0 = a|c
 222        add     h, d                    # d = d + h + S1 + CH + k + w
 223        and     c, y2                   # y2 = a&c
 224        ## compute low s1
 225        vpshufd $0b11111010, X3, XTMP2  # XTMP2 = W[-2] {BBAA}
 226        and     b, y0                   # y0 = (a|c)&b
 227        add     y1, h                   # h = h + S1 + CH + k + w + S0
 228        vpaddd  XTMP1, XTMP0, XTMP0     # XTMP0 = W[-16] + W[-7] + s0
 229        or      y2, y0                  # y0 = MAJ = (a|c)&b)|(a&c)
 230        add     y0, h                   # h = h + S1 + CH + k + w + S0 + MAJ
 231        ROTATE_ARGS
 232        mov     e, y0                   # y0 = e
 233        mov     a, y1                   # y1 = a
 234        MY_ROR  (25-11), y0             # y0 = e >> (25-11)
 235        xor     e, y0                   # y0 = e ^ (e >> (25-11))
 236        MY_ROR  (22-13), y1             # y1 = a >> (22-13)
 237        mov     f, y2                   # y2 = f
 238        xor     a, y1                   # y1 = a ^ (a >> (22-13)
 239        MY_ROR  (11-6), y0              # y0 = (e >> (11-6)) ^ (e >> (25-6))
 240        vpsrld  $10, XTMP2, XTMP4       # XTMP4 = W[-2] >> 10 {BBAA}
 241        xor     g, y2                   # y2 = f^g
 242        vpsrlq  $19, XTMP2, XTMP3       # XTMP3 = W[-2] MY_ROR 19 {xBxA}
 243        xor     e, y0                   # y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
 244        and     e, y2                   # y2 = (f^g)&e
 245        vpsrlq  $17, XTMP2, XTMP2       # XTMP2 = W[-2] MY_ROR 17 {xBxA}
 246        MY_ROR  (13-2), y1              # y1 = (a >> (13-2)) ^ (a >> (22-2))
 247        xor     a, y1                   # y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
 248        xor     g, y2                   # y2 = CH = ((f^g)&e)^g
 249        MY_ROR  6, y0                   # y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
 250        vpxor   XTMP3, XTMP2, XTMP2     #
 251        add     y0, y2                  # y2 = S1 + CH
 252        MY_ROR  2, y1                   # y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
 253        add     (2*4 + _XFER)(%rsp), y2 # y2 = k + w + S1 + CH
 254        vpxor   XTMP2, XTMP4, XTMP4     # XTMP4 = s1 {xBxA}
 255        mov     a, y0                   # y0 = a
 256        add     y2, h                   # h = h + S1 + CH + k + w
 257        mov     a, y2                   # y2 = a
 258        vpshufb SHUF_00BA, XTMP4, XTMP4 # XTMP4 = s1 {00BA}
 259        or      c, y0                   # y0 = a|c
 260        add     h, d                    # d = d + h + S1 + CH + k + w
 261        and     c, y2                   # y2 = a&c
 262        vpaddd  XTMP4, XTMP0, XTMP0     # XTMP0 = {..., ..., W[1], W[0]}
 263        and     b, y0                   # y0 = (a|c)&b
 264        add     y1, h                   # h = h + S1 + CH + k + w + S0
 265        ## compute high s1
 266        vpshufd $0b01010000, XTMP0, XTMP2 # XTMP2 = W[-2] {DDCC}
 267        or      y2, y0                  # y0 = MAJ = (a|c)&b)|(a&c)
 268        add     y0, h                   # h = h + S1 + CH + k + w + S0 + MAJ
 269        ROTATE_ARGS
 270        mov     e, y0                   # y0 = e
 271        MY_ROR  (25-11), y0             # y0 = e >> (25-11)
 272        mov     a, y1                   # y1 = a
 273        MY_ROR  (22-13), y1             # y1 = a >> (22-13)
 274        xor     e, y0                   # y0 = e ^ (e >> (25-11))
 275        mov     f, y2                   # y2 = f
 276        MY_ROR  (11-6), y0              # y0 = (e >> (11-6)) ^ (e >> (25-6))
 277        vpsrld  $10, XTMP2, XTMP5       # XTMP5 = W[-2] >> 10 {DDCC}
 278        xor     a, y1                   # y1 = a ^ (a >> (22-13)
 279        xor     g, y2                   # y2 = f^g
 280        vpsrlq  $19, XTMP2, XTMP3       # XTMP3 = W[-2] MY_ROR 19 {xDxC}
 281        xor     e, y0                   # y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
 282        and     e, y2                   # y2 = (f^g)&e
 283        MY_ROR  (13-2), y1              # y1 = (a >> (13-2)) ^ (a >> (22-2))
 284        vpsrlq  $17, XTMP2, XTMP2       # XTMP2 = W[-2] MY_ROR 17 {xDxC}
 285        xor     a, y1                   # y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
 286        MY_ROR  6, y0                   # y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
 287        xor     g, y2                   # y2 = CH = ((f^g)&e)^g
 288        vpxor   XTMP3, XTMP2, XTMP2
 289        MY_ROR  2, y1                   # y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
 290        add     y0, y2                  # y2 = S1 + CH
 291        add     (3*4 + _XFER)(%rsp), y2 # y2 = k + w + S1 + CH
 292        vpxor   XTMP2, XTMP5, XTMP5     # XTMP5 = s1 {xDxC}
 293        mov     a, y0                   # y0 = a
 294        add     y2, h                   # h = h + S1 + CH + k + w
 295        mov     a, y2                   # y2 = a
 296        vpshufb SHUF_DC00, XTMP5, XTMP5 # XTMP5 = s1 {DC00}
 297        or      c, y0                   # y0 = a|c
 298        add     h, d                    # d = d + h + S1 + CH + k + w
 299        and     c, y2                   # y2 = a&c
 300        vpaddd  XTMP0, XTMP5, X0        # X0 = {W[3], W[2], W[1], W[0]}
 301        and     b, y0                   # y0 = (a|c)&b
 302        add     y1, h                   # h = h + S1 + CH + k + w + S0
 303        or      y2, y0                  # y0 = MAJ = (a|c)&b)|(a&c)
 304        add     y0, h                   # h = h + S1 + CH + k + w + S0 + MAJ
 305        ROTATE_ARGS
 306        rotate_Xs
 307.endm
 308
 309## input is [rsp + _XFER + %1 * 4]
 310.macro DO_ROUND round
 311        mov     e, y0                   # y0 = e
 312        MY_ROR  (25-11), y0             # y0 = e >> (25-11)
 313        mov     a, y1                   # y1 = a
 314        xor     e, y0                   # y0 = e ^ (e >> (25-11))
 315        MY_ROR  (22-13), y1             # y1 = a >> (22-13)
 316        mov     f, y2                   # y2 = f
 317        xor     a, y1                   # y1 = a ^ (a >> (22-13)
 318        MY_ROR  (11-6), y0              # y0 = (e >> (11-6)) ^ (e >> (25-6))
 319        xor     g, y2                   # y2 = f^g
 320        xor     e, y0                   # y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))
 321        MY_ROR  (13-2), y1              # y1 = (a >> (13-2)) ^ (a >> (22-2))
 322        and     e, y2                   # y2 = (f^g)&e
 323        xor     a, y1                   # y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))
 324        MY_ROR  6, y0                   # y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)
 325        xor     g, y2                   # y2 = CH = ((f^g)&e)^g
 326        add     y0, y2                  # y2 = S1 + CH
 327        MY_ROR  2, y1                   # y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)
 328        offset = \round * 4 + _XFER     #
 329        add     offset(%rsp), y2        # y2 = k + w + S1 + CH
 330        mov     a, y0                   # y0 = a
 331        add     y2, h                   # h = h + S1 + CH + k + w
 332        mov     a, y2                   # y2 = a
 333        or      c, y0                   # y0 = a|c
 334        add     h, d                    # d = d + h + S1 + CH + k + w
 335        and     c, y2                   # y2 = a&c
 336        and     b, y0                   # y0 = (a|c)&b
 337        add     y1, h                   # h = h + S1 + CH + k + w + S0
 338        or      y2, y0                  # y0 = MAJ = (a|c)&b)|(a&c)
 339        add     y0, h                   # h = h + S1 + CH + k + w + S0 + MAJ
 340        ROTATE_ARGS
 341.endm
 342
 343########################################################################
 344## void sha256_transform_avx(state sha256_state *state, const u8 *data, int blocks)
 345## arg 1 : pointer to state
 346## arg 2 : pointer to input data
 347## arg 3 : Num blocks
 348########################################################################
 349.text
 350SYM_FUNC_START(sha256_transform_avx)
 351.align 32
 352        pushq   %rbx
 353        pushq   %r12
 354        pushq   %r13
 355        pushq   %r14
 356        pushq   %r15
 357        pushq   %rbp
 358        movq    %rsp, %rbp
 359
 360        subq    $STACK_SIZE, %rsp       # allocate stack space
 361        and     $~15, %rsp              # align stack pointer
 362
 363        shl     $6, NUM_BLKS            # convert to bytes
 364        jz      done_hash
 365        add     INP, NUM_BLKS           # pointer to end of data
 366        mov     NUM_BLKS, _INP_END(%rsp)
 367
 368        ## load initial digest
 369        mov     4*0(CTX), a
 370        mov     4*1(CTX), b
 371        mov     4*2(CTX), c
 372        mov     4*3(CTX), d
 373        mov     4*4(CTX), e
 374        mov     4*5(CTX), f
 375        mov     4*6(CTX), g
 376        mov     4*7(CTX), h
 377
 378        vmovdqa  PSHUFFLE_BYTE_FLIP_MASK(%rip), BYTE_FLIP_MASK
 379        vmovdqa  _SHUF_00BA(%rip), SHUF_00BA
 380        vmovdqa  _SHUF_DC00(%rip), SHUF_DC00
 381loop0:
 382        lea     K256(%rip), TBL
 383
 384        ## byte swap first 16 dwords
 385        COPY_XMM_AND_BSWAP      X0, 0*16(INP), BYTE_FLIP_MASK
 386        COPY_XMM_AND_BSWAP      X1, 1*16(INP), BYTE_FLIP_MASK
 387        COPY_XMM_AND_BSWAP      X2, 2*16(INP), BYTE_FLIP_MASK
 388        COPY_XMM_AND_BSWAP      X3, 3*16(INP), BYTE_FLIP_MASK
 389
 390        mov     INP, _INP(%rsp)
 391
 392        ## schedule 48 input dwords, by doing 3 rounds of 16 each
 393        mov     $3, SRND
 394.align 16
 395loop1:
 396        vpaddd  (TBL), X0, XFER
 397        vmovdqa XFER, _XFER(%rsp)
 398        FOUR_ROUNDS_AND_SCHED
 399
 400        vpaddd  1*16(TBL), X0, XFER
 401        vmovdqa XFER, _XFER(%rsp)
 402        FOUR_ROUNDS_AND_SCHED
 403
 404        vpaddd  2*16(TBL), X0, XFER
 405        vmovdqa XFER, _XFER(%rsp)
 406        FOUR_ROUNDS_AND_SCHED
 407
 408        vpaddd  3*16(TBL), X0, XFER
 409        vmovdqa XFER, _XFER(%rsp)
 410        add     $4*16, TBL
 411        FOUR_ROUNDS_AND_SCHED
 412
 413        sub     $1, SRND
 414        jne     loop1
 415
 416        mov     $2, SRND
 417loop2:
 418        vpaddd  (TBL), X0, XFER
 419        vmovdqa XFER, _XFER(%rsp)
 420        DO_ROUND        0
 421        DO_ROUND        1
 422        DO_ROUND        2
 423        DO_ROUND        3
 424
 425        vpaddd  1*16(TBL), X1, XFER
 426        vmovdqa XFER, _XFER(%rsp)
 427        add     $2*16, TBL
 428        DO_ROUND        0
 429        DO_ROUND        1
 430        DO_ROUND        2
 431        DO_ROUND        3
 432
 433        vmovdqa X2, X0
 434        vmovdqa X3, X1
 435
 436        sub     $1, SRND
 437        jne     loop2
 438
 439        addm    (4*0)(CTX),a
 440        addm    (4*1)(CTX),b
 441        addm    (4*2)(CTX),c
 442        addm    (4*3)(CTX),d
 443        addm    (4*4)(CTX),e
 444        addm    (4*5)(CTX),f
 445        addm    (4*6)(CTX),g
 446        addm    (4*7)(CTX),h
 447
 448        mov     _INP(%rsp), INP
 449        add     $64, INP
 450        cmp     _INP_END(%rsp), INP
 451        jne     loop0
 452
 453done_hash:
 454
 455        mov     %rbp, %rsp
 456        popq    %rbp
 457        popq    %r15
 458        popq    %r14
 459        popq    %r13
 460        popq    %r12
 461        popq    %rbx
 462        ret
 463SYM_FUNC_END(sha256_transform_avx)
 464
 465.section        .rodata.cst256.K256, "aM", @progbits, 256
 466.align 64
 467K256:
 468        .long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
 469        .long 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
 470        .long 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
 471        .long 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
 472        .long 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
 473        .long 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
 474        .long 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
 475        .long 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
 476        .long 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
 477        .long 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
 478        .long 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
 479        .long 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
 480        .long 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
 481        .long 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
 482        .long 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
 483        .long 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
 484
 485.section        .rodata.cst16.PSHUFFLE_BYTE_FLIP_MASK, "aM", @progbits, 16
 486.align 16
 487PSHUFFLE_BYTE_FLIP_MASK:
 488        .octa 0x0c0d0e0f08090a0b0405060700010203
 489
 490.section        .rodata.cst16._SHUF_00BA, "aM", @progbits, 16
 491.align 16
 492# shuffle xBxA -> 00BA
 493_SHUF_00BA:
 494        .octa 0xFFFFFFFFFFFFFFFF0b0a090803020100
 495
 496.section        .rodata.cst16._SHUF_DC00, "aM", @progbits, 16
 497.align 16
 498# shuffle xDxC -> DC00
 499_SHUF_DC00:
 500        .octa 0x0b0a090803020100FFFFFFFFFFFFFFFF
 501
 502#endif
 503