arch/x86/crypto/crct10dif-pcl-asm_64.S

   1 ########################################################################
   2 # Implement fast CRC-T10DIF computation with SSE and PCLMULQDQ instructions
   3 #
   4 # Copyright (c) 2013, Intel Corporation
   5 #
   6 # Authors:
   7 #     Erdinc Ozturk <erdinc.ozturk@intel.com>
   8 #     Vinodh Gopal <vinodh.gopal@intel.com>
   9 #     James Guilford <james.guilford@intel.com>
  10 #     Tim Chen <tim.c.chen@linux.intel.com>
  11 #
  12 # This software is available to you under a choice of one of two
  13 # licenses.  You may choose to be licensed under the terms of the GNU
  14 # General Public License (GPL) Version 2, available from the file
  15 # COPYING in the main directory of this source tree, or the
  16 # OpenIB.org BSD license below:
  17 #
  18 # Redistribution and use in source and binary forms, with or without
  19 # modification, are permitted provided that the following conditions are
  20 # met:
  21 #
  22 # * Redistributions of source code must retain the above copyright
  23 #   notice, this list of conditions and the following disclaimer.
  24 #
  25 # * Redistributions in binary form must reproduce the above copyright
  26 #   notice, this list of conditions and the following disclaimer in the
  27 #   documentation and/or other materials provided with the
  28 #   distribution.
  29 #
  30 # * Neither the name of the Intel Corporation nor the names of its
  31 #   contributors may be used to endorse or promote products derived from
  32 #   this software without specific prior written permission.
  33 #
  34 #
  35 # THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY
  36 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR
  39 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  40 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  41 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  42 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  43 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  44 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  45 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46 ########################################################################
  47 #       Function API:
  48 #       UINT16 crc_t10dif_pcl(
  49 #               UINT16 init_crc, //initial CRC value, 16 bits
  50 #               const unsigned char *buf, //buffer pointer to calculate CRC on
  51 #               UINT64 len //buffer length in bytes (64-bit data)
  52 #       );
  53 #
  54 #       Reference paper titled "Fast CRC Computation for Generic
  55 #       Polynomials Using PCLMULQDQ Instruction"
  56 #       URL: http://www.intel.com/content/dam/www/public/us/en/documents
  57 #  /white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
  58 #
  59 #
  60
  61 #include <linux/linkage.h>
  62
  63 .text
  64
  65 #define        arg1 %rdi
  66 #define        arg2 %rsi
  67 #define        arg3 %rdx
  68
  69 #define        arg1_low32 %edi
  70
  71 ENTRY(crc_t10dif_pcl)
  72 .align 16
  73
  74         # adjust the 16-bit initial_crc value, scale it to 32 bits
  75         shl     $16, arg1_low32
  76
  77         # Allocate Stack Space
  78         mov     %rsp, %rcx
  79         sub     $16*2, %rsp
  80         # align stack to 16 byte boundary
  81         and     $~(0x10 - 1), %rsp
  82
  83         # check if smaller than 256
  84         cmp     $256, arg3
  85
  86         # for sizes less than 128, we can't fold 64B at a time...
  87         jl      _less_than_128
  88
  89
  90         # load the initial crc value
  91         movd    arg1_low32, %xmm10      # initial crc
  92
  93         # crc value does not need to be byte-reflected, but it needs
  94         # to be moved to the high part of the register.
  95         # because data will be byte-reflected and will align with
  96         # initial crc at correct place.
  97         pslldq  $12, %xmm10
  98
  99         movdqa  SHUF_MASK(%rip), %xmm11
 100         # receive the initial 64B data, xor the initial crc value
 101         movdqu  16*0(arg2), %xmm0
 102         movdqu  16*1(arg2), %xmm1
 103         movdqu  16*2(arg2), %xmm2
 104         movdqu  16*3(arg2), %xmm3
 105         movdqu  16*4(arg2), %xmm4
 106         movdqu  16*5(arg2), %xmm5
 107         movdqu  16*6(arg2), %xmm6
 108         movdqu  16*7(arg2), %xmm7
 109
 110         pshufb  %xmm11, %xmm0
 111         # XOR the initial_crc value
 112         pxor    %xmm10, %xmm0
 113         pshufb  %xmm11, %xmm1
 114         pshufb  %xmm11, %xmm2
 115         pshufb  %xmm11, %xmm3
 116         pshufb  %xmm11, %xmm4
 117         pshufb  %xmm11, %xmm5
 118         pshufb  %xmm11, %xmm6
 119         pshufb  %xmm11, %xmm7
 120
 121         movdqa  rk3(%rip), %xmm10       #xmm10 has rk3 and rk4
 122                                         #imm value of pclmulqdq instruction
 123                                         #will determine which constant to use
 124
 125         #################################################################
 126         # we subtract 256 instead of 128 to save one instruction from the loop
 127         sub     $256, arg3
 128
 129         # at this section of the code, there is 64*x+y (0<=y<64) bytes of
 130         # buffer. The _fold_64_B_loop will fold 64B at a time
 131         # until we have 64+y Bytes of buffer
 132
 133
 134         # fold 64B at a time. This section of the code folds 4 xmm
 135         # registers in parallel
 136 _fold_64_B_loop:
 137
 138         # update the buffer pointer
 139         add     $128, arg2              #    buf += 64#
 140
 141         movdqu  16*0(arg2), %xmm9
 142         movdqu  16*1(arg2), %xmm12
 143         pshufb  %xmm11, %xmm9
 144         pshufb  %xmm11, %xmm12
 145         movdqa  %xmm0, %xmm8
 146         movdqa  %xmm1, %xmm13
 147         pclmulqdq       $0x0 , %xmm10, %xmm0
 148         pclmulqdq       $0x11, %xmm10, %xmm8
 149         pclmulqdq       $0x0 , %xmm10, %xmm1
 150         pclmulqdq       $0x11, %xmm10, %xmm13
 151         pxor    %xmm9 , %xmm0
 152         xorps   %xmm8 , %xmm0
 153         pxor    %xmm12, %xmm1
 154         xorps   %xmm13, %xmm1
 155
 156         movdqu  16*2(arg2), %xmm9
 157         movdqu  16*3(arg2), %xmm12
 158         pshufb  %xmm11, %xmm9
 159         pshufb  %xmm11, %xmm12
 160         movdqa  %xmm2, %xmm8
 161         movdqa  %xmm3, %xmm13
 162         pclmulqdq       $0x0, %xmm10, %xmm2
 163         pclmulqdq       $0x11, %xmm10, %xmm8
 164         pclmulqdq       $0x0, %xmm10, %xmm3
 165         pclmulqdq       $0x11, %xmm10, %xmm13
 166         pxor    %xmm9 , %xmm2
 167         xorps   %xmm8 , %xmm2
 168         pxor    %xmm12, %xmm3
 169         xorps   %xmm13, %xmm3
 170
 171         movdqu  16*4(arg2), %xmm9
 172         movdqu  16*5(arg2), %xmm12
 173         pshufb  %xmm11, %xmm9
 174         pshufb  %xmm11, %xmm12
 175         movdqa  %xmm4, %xmm8
 176         movdqa  %xmm5, %xmm13
 177         pclmulqdq       $0x0,  %xmm10, %xmm4
 178         pclmulqdq       $0x11, %xmm10, %xmm8
 179         pclmulqdq       $0x0,  %xmm10, %xmm5
 180         pclmulqdq       $0x11, %xmm10, %xmm13
 181         pxor    %xmm9 ,  %xmm4
 182         xorps   %xmm8 ,  %xmm4
 183         pxor    %xmm12,  %xmm5
 184         xorps   %xmm13,  %xmm5
 185
 186         movdqu  16*6(arg2), %xmm9
 187         movdqu  16*7(arg2), %xmm12
 188         pshufb  %xmm11, %xmm9
 189         pshufb  %xmm11, %xmm12
 190         movdqa  %xmm6 , %xmm8
 191         movdqa  %xmm7 , %xmm13
 192         pclmulqdq       $0x0 , %xmm10, %xmm6
 193         pclmulqdq       $0x11, %xmm10, %xmm8
 194         pclmulqdq       $0x0 , %xmm10, %xmm7
 195         pclmulqdq       $0x11, %xmm10, %xmm13
 196         pxor    %xmm9 , %xmm6
 197         xorps   %xmm8 , %xmm6
 198         pxor    %xmm12, %xmm7
 199         xorps   %xmm13, %xmm7
 200
 201         sub     $128, arg3
 202
 203         # check if there is another 64B in the buffer to be able to fold
 204         jge     _fold_64_B_loop
 205         ##################################################################
 206
 207
 208         add     $128, arg2
 209         # at this point, the buffer pointer is pointing at the last y Bytes
 210         # of the buffer the 64B of folded data is in 4 of the xmm
 211         # registers: xmm0, xmm1, xmm2, xmm3
 212
 213
 214         # fold the 8 xmm registers to 1 xmm register with different constants
 215
 216         movdqa  rk9(%rip), %xmm10
 217         movdqa  %xmm0, %xmm8
 218         pclmulqdq       $0x11, %xmm10, %xmm0
 219         pclmulqdq       $0x0 , %xmm10, %xmm8
 220         pxor    %xmm8, %xmm7
 221         xorps   %xmm0, %xmm7
 222
 223         movdqa  rk11(%rip), %xmm10
 224         movdqa  %xmm1, %xmm8
 225         pclmulqdq        $0x11, %xmm10, %xmm1
 226         pclmulqdq        $0x0 , %xmm10, %xmm8
 227         pxor    %xmm8, %xmm7
 228         xorps   %xmm1, %xmm7
 229
 230         movdqa  rk13(%rip), %xmm10
 231         movdqa  %xmm2, %xmm8
 232         pclmulqdq        $0x11, %xmm10, %xmm2
 233         pclmulqdq        $0x0 , %xmm10, %xmm8
 234         pxor    %xmm8, %xmm7
 235         pxor    %xmm2, %xmm7
 236
 237         movdqa  rk15(%rip), %xmm10
 238         movdqa  %xmm3, %xmm8
 239         pclmulqdq       $0x11, %xmm10, %xmm3
 240         pclmulqdq       $0x0 , %xmm10, %xmm8
 241         pxor    %xmm8, %xmm7
 242         xorps   %xmm3, %xmm7
 243
 244         movdqa  rk17(%rip), %xmm10
 245         movdqa  %xmm4, %xmm8
 246         pclmulqdq       $0x11, %xmm10, %xmm4
 247         pclmulqdq       $0x0 , %xmm10, %xmm8
 248         pxor    %xmm8, %xmm7
 249         pxor    %xmm4, %xmm7
 250
 251         movdqa  rk19(%rip), %xmm10
 252         movdqa  %xmm5, %xmm8
 253         pclmulqdq       $0x11, %xmm10, %xmm5
 254         pclmulqdq       $0x0 , %xmm10, %xmm8
 255         pxor    %xmm8, %xmm7
 256         xorps   %xmm5, %xmm7
 257
 258         movdqa  rk1(%rip), %xmm10       #xmm10 has rk1 and rk2
 259                                         #imm value of pclmulqdq instruction
 260                                         #will determine which constant to use
 261         movdqa  %xmm6, %xmm8
 262         pclmulqdq       $0x11, %xmm10, %xmm6
 263         pclmulqdq       $0x0 , %xmm10, %xmm8
 264         pxor    %xmm8, %xmm7
 265         pxor    %xmm6, %xmm7
 266
 267
 268         # instead of 64, we add 48 to the loop counter to save 1 instruction
 269         # from the loop instead of a cmp instruction, we use the negative
 270         # flag with the jl instruction
 271         add     $128-16, arg3
 272         jl      _final_reduction_for_128
 273
 274         # now we have 16+y bytes left to reduce. 16 Bytes is in register xmm7
 275         # and the rest is in memory. We can fold 16 bytes at a time if y>=16
 276         # continue folding 16B at a time
 277
 278 _16B_reduction_loop:
 279         movdqa  %xmm7, %xmm8
 280         pclmulqdq       $0x11, %xmm10, %xmm7
 281         pclmulqdq       $0x0 , %xmm10, %xmm8
 282         pxor    %xmm8, %xmm7
 283         movdqu  (arg2), %xmm0
 284         pshufb  %xmm11, %xmm0
 285         pxor    %xmm0 , %xmm7
 286         add     $16, arg2
 287         sub     $16, arg3
 288         # instead of a cmp instruction, we utilize the flags with the
 289         # jge instruction equivalent of: cmp arg3, 16-16
 290         # check if there is any more 16B in the buffer to be able to fold
 291         jge     _16B_reduction_loop
 292
 293         #now we have 16+z bytes left to reduce, where 0<= z < 16.
 294         #first, we reduce the data in the xmm7 register
 295
 296
 297 _final_reduction_for_128:
 298         # check if any more data to fold. If not, compute the CRC of
 299         # the final 128 bits
 300         add     $16, arg3
 301         je      _128_done
 302
 303         # here we are getting data that is less than 16 bytes.
 304         # since we know that there was data before the pointer, we can
 305         # offset the input pointer before the actual point, to receive
 306         # exactly 16 bytes. after that the registers need to be adjusted.
 307 _get_last_two_xmms:
 308         movdqa  %xmm7, %xmm2
 309
 310         movdqu  -16(arg2, arg3), %xmm1
 311         pshufb  %xmm11, %xmm1
 312
 313         # get rid of the extra data that was loaded before
 314         # load the shift constant
 315         lea     pshufb_shf_table+16(%rip), %rax
 316         sub     arg3, %rax
 317         movdqu  (%rax), %xmm0
 318
 319         # shift xmm2 to the left by arg3 bytes
 320         pshufb  %xmm0, %xmm2
 321
 322         # shift xmm7 to the right by 16-arg3 bytes
 323         pxor    mask1(%rip), %xmm0
 324         pshufb  %xmm0, %xmm7
 325         pblendvb        %xmm2, %xmm1    #xmm0 is implicit
 326
 327         # fold 16 Bytes
 328         movdqa  %xmm1, %xmm2
 329         movdqa  %xmm7, %xmm8
 330         pclmulqdq       $0x11, %xmm10, %xmm7
 331         pclmulqdq       $0x0 , %xmm10, %xmm8
 332         pxor    %xmm8, %xmm7
 333         pxor    %xmm2, %xmm7
 334
 335 _128_done:
 336         # compute crc of a 128-bit value
 337         movdqa  rk5(%rip), %xmm10       # rk5 and rk6 in xmm10
 338         movdqa  %xmm7, %xmm0
 339
 340         #64b fold
 341         pclmulqdq       $0x1, %xmm10, %xmm7
 342         pslldq  $8   ,  %xmm0
 343         pxor    %xmm0,  %xmm7
 344
 345         #32b fold
 346         movdqa  %xmm7, %xmm0
 347
 348         pand    mask2(%rip), %xmm0
 349
 350         psrldq  $12, %xmm7
 351         pclmulqdq       $0x10, %xmm10, %xmm7
 352         pxor    %xmm0, %xmm7
 353
 354         #barrett reduction
 355 _barrett:
 356         movdqa  rk7(%rip), %xmm10       # rk7 and rk8 in xmm10
 357         movdqa  %xmm7, %xmm0
 358         pclmulqdq       $0x01, %xmm10, %xmm7
 359         pslldq  $4, %xmm7
 360         pclmulqdq       $0x11, %xmm10, %xmm7
 361
 362         pslldq  $4, %xmm7
 363         pxor    %xmm0, %xmm7
 364         pextrd  $1, %xmm7, %eax
 365
 366 _cleanup:
 367         # scale the result back to 16 bits
 368         shr     $16, %eax
 369         mov     %rcx, %rsp
 370         ret
 371
 372 ########################################################################
 373
 374 .align 16
 375 _less_than_128:
 376
 377         # check if there is enough buffer to be able to fold 16B at a time
 378         cmp     $32, arg3
 379         jl      _less_than_32
 380         movdqa  SHUF_MASK(%rip), %xmm11
 381
 382         # now if there is, load the constants
 383         movdqa  rk1(%rip), %xmm10       # rk1 and rk2 in xmm10
 384
 385         movd    arg1_low32, %xmm0       # get the initial crc value
 386         pslldq  $12, %xmm0      # align it to its correct place
 387         movdqu  (arg2), %xmm7   # load the plaintext
 388         pshufb  %xmm11, %xmm7   # byte-reflect the plaintext
 389         pxor    %xmm0, %xmm7
 390
 391
 392         # update the buffer pointer
 393         add     $16, arg2
 394
 395         # update the counter. subtract 32 instead of 16 to save one
 396         # instruction from the loop
 397         sub     $32, arg3
 398
 399         jmp     _16B_reduction_loop
 400
 401
 402 .align 16
 403 _less_than_32:
 404         # mov initial crc to the return value. this is necessary for
 405         # zero-length buffers.
 406         mov     arg1_low32, %eax
 407         test    arg3, arg3
 408         je      _cleanup
 409
 410         movdqa  SHUF_MASK(%rip), %xmm11
 411
 412         movd    arg1_low32, %xmm0       # get the initial crc value
 413         pslldq  $12, %xmm0      # align it to its correct place
 414
 415         cmp     $16, arg3
 416         je      _exact_16_left
 417         jl      _less_than_16_left
 418
 419         movdqu  (arg2), %xmm7   # load the plaintext
 420         pshufb  %xmm11, %xmm7   # byte-reflect the plaintext
 421         pxor    %xmm0 , %xmm7   # xor the initial crc value
 422         add     $16, arg2
 423         sub     $16, arg3
 424         movdqa  rk1(%rip), %xmm10       # rk1 and rk2 in xmm10
 425         jmp     _get_last_two_xmms
 426
 427
 428 .align 16
 429 _less_than_16_left:
 430         # use stack space to load data less than 16 bytes, zero-out
 431         # the 16B in memory first.
 432
 433         pxor    %xmm1, %xmm1
 434         mov     %rsp, %r11
 435         movdqa  %xmm1, (%r11)
 436
 437         cmp     $4, arg3
 438         jl      _only_less_than_4
 439
 440         # backup the counter value
 441         mov     arg3, %r9
 442         cmp     $8, arg3
 443         jl      _less_than_8_left
 444
 445         # load 8 Bytes
 446         mov     (arg2), %rax
 447         mov     %rax, (%r11)
 448         add     $8, %r11
 449         sub     $8, arg3
 450         add     $8, arg2
 451 _less_than_8_left:
 452
 453         cmp     $4, arg3
 454         jl      _less_than_4_left
 455
 456         # load 4 Bytes
 457         mov     (arg2), %eax
 458         mov     %eax, (%r11)
 459         add     $4, %r11
 460         sub     $4, arg3
 461         add     $4, arg2
 462 _less_than_4_left:
 463
 464         cmp     $2, arg3
 465         jl      _less_than_2_left
 466
 467         # load 2 Bytes
 468         mov     (arg2), %ax
 469         mov     %ax, (%r11)
 470         add     $2, %r11
 471         sub     $2, arg3
 472         add     $2, arg2
 473 _less_than_2_left:
 474         cmp     $1, arg3
 475         jl      _zero_left
 476
 477         # load 1 Byte
 478         mov     (arg2), %al
 479         mov     %al, (%r11)
 480 _zero_left:
 481         movdqa  (%rsp), %xmm7
 482         pshufb  %xmm11, %xmm7
 483         pxor    %xmm0 , %xmm7   # xor the initial crc value
 484
 485         # shl r9, 4
 486         lea     pshufb_shf_table+16(%rip), %rax
 487         sub     %r9, %rax
 488         movdqu  (%rax), %xmm0
 489         pxor    mask1(%rip), %xmm0
 490
 491         pshufb  %xmm0, %xmm7
 492         jmp     _128_done
 493
 494 .align 16
 495 _exact_16_left:
 496         movdqu  (arg2), %xmm7
 497         pshufb  %xmm11, %xmm7
 498         pxor    %xmm0 , %xmm7   # xor the initial crc value
 499
 500         jmp     _128_done
 501
 502 _only_less_than_4:
 503         cmp     $3, arg3
 504         jl      _only_less_than_3
 505
 506         # load 3 Bytes
 507         mov     (arg2), %al
 508         mov     %al, (%r11)
 509
 510         mov     1(arg2), %al
 511         mov     %al, 1(%r11)
 512
 513         mov     2(arg2), %al
 514         mov     %al, 2(%r11)
 515
 516         movdqa   (%rsp), %xmm7
 517         pshufb   %xmm11, %xmm7
 518         pxor     %xmm0 , %xmm7  # xor the initial crc value
 519
 520         psrldq  $5, %xmm7
 521
 522         jmp     _barrett
 523 _only_less_than_3:
 524         cmp     $2, arg3
 525         jl      _only_less_than_2
 526
 527         # load 2 Bytes
 528         mov     (arg2), %al
 529         mov     %al, (%r11)
 530
 531         mov     1(arg2), %al
 532         mov     %al, 1(%r11)
 533
 534         movdqa  (%rsp), %xmm7
 535         pshufb  %xmm11, %xmm7
 536         pxor    %xmm0 , %xmm7   # xor the initial crc value
 537
 538         psrldq  $6, %xmm7
 539
 540         jmp     _barrett
 541 _only_less_than_2:
 542
 543         # load 1 Byte
 544         mov     (arg2), %al
 545         mov     %al, (%r11)
 546
 547         movdqa  (%rsp), %xmm7
 548         pshufb  %xmm11, %xmm7
 549         pxor    %xmm0 , %xmm7   # xor the initial crc value
 550
 551         psrldq  $7, %xmm7
 552
 553         jmp     _barrett
 554
 555 ENDPROC(crc_t10dif_pcl)
 556
 557 .section        .rodata, "a", @progbits
 558 .align 16
 559 # precomputed constants
 560 # these constants are precomputed from the poly:
 561 # 0x8bb70000 (0x8bb7 scaled to 32 bits)
 562 # Q = 0x18BB70000
 563 # rk1 = 2^(32*3) mod Q << 32
 564 # rk2 = 2^(32*5) mod Q << 32
 565 # rk3 = 2^(32*15) mod Q << 32
 566 # rk4 = 2^(32*17) mod Q << 32
 567 # rk5 = 2^(32*3) mod Q << 32
 568 # rk6 = 2^(32*2) mod Q << 32
 569 # rk7 = floor(2^64/Q)
 570 # rk8 = Q
 571 rk1:
 572 .quad 0x2d56000000000000
 573 rk2:
 574 .quad 0x06df000000000000
 575 rk3:
 576 .quad 0x9d9d000000000000
 577 rk4:
 578 .quad 0x7cf5000000000000
 579 rk5:
 580 .quad 0x2d56000000000000
 581 rk6:
 582 .quad 0x1368000000000000
 583 rk7:
 584 .quad 0x00000001f65a57f8
 585 rk8:
 586 .quad 0x000000018bb70000
 587
 588 rk9:
 589 .quad 0xceae000000000000
 590 rk10:
 591 .quad 0xbfd6000000000000
 592 rk11:
 593 .quad 0x1e16000000000000
 594 rk12:
 595 .quad 0x713c000000000000
 596 rk13:
 597 .quad 0xf7f9000000000000
 598 rk14:
 599 .quad 0x80a6000000000000
 600 rk15:
 601 .quad 0x044c000000000000
 602 rk16:
 603 .quad 0xe658000000000000
 604 rk17:
 605 .quad 0xad18000000000000
 606 rk18:
 607 .quad 0xa497000000000000
 608 rk19:
 609 .quad 0x6ee3000000000000
 610 rk20:
 611 .quad 0xe7b5000000000000
 612
 613
 614
 615 .section        .rodata.cst16.mask1, "aM", @progbits, 16
 616 .align 16
 617 mask1:
 618 .octa 0x80808080808080808080808080808080
 619
 620 .section        .rodata.cst16.mask2, "aM", @progbits, 16
 621 .align 16
 622 mask2:
 623 .octa 0x00000000FFFFFFFFFFFFFFFFFFFFFFFF
 624
 625 .section        .rodata.cst16.SHUF_MASK, "aM", @progbits, 16
 626 .align 16
 627 SHUF_MASK:
 628 .octa 0x000102030405060708090A0B0C0D0E0F
 629
 630 .section        .rodata.cst32.pshufb_shf_table, "aM", @progbits, 32
 631 .align 32
 632 pshufb_shf_table:
 633 # use these values for shift constants for the pshufb instruction
 634 # different alignments result in values as shown:
 635 #       DDQ 0x008f8e8d8c8b8a898887868584838281 # shl 15 (16-1) / shr1
 636 #       DDQ 0x01008f8e8d8c8b8a8988878685848382 # shl 14 (16-3) / shr2
 637 #       DDQ 0x0201008f8e8d8c8b8a89888786858483 # shl 13 (16-4) / shr3
 638 #       DDQ 0x030201008f8e8d8c8b8a898887868584 # shl 12 (16-4) / shr4
 639 #       DDQ 0x04030201008f8e8d8c8b8a8988878685 # shl 11 (16-5) / shr5
 640 #       DDQ 0x0504030201008f8e8d8c8b8a89888786 # shl 10 (16-6) / shr6
 641 #       DDQ 0x060504030201008f8e8d8c8b8a898887 # shl 9  (16-7) / shr7
 642 #       DDQ 0x07060504030201008f8e8d8c8b8a8988 # shl 8  (16-8) / shr8
 643 #       DDQ 0x0807060504030201008f8e8d8c8b8a89 # shl 7  (16-9) / shr9
 644 #       DDQ 0x090807060504030201008f8e8d8c8b8a # shl 6  (16-10) / shr10
 645 #       DDQ 0x0a090807060504030201008f8e8d8c8b # shl 5  (16-11) / shr11
 646 #       DDQ 0x0b0a090807060504030201008f8e8d8c # shl 4  (16-12) / shr12
 647 #       DDQ 0x0c0b0a090807060504030201008f8e8d # shl 3  (16-13) / shr13
 648 #       DDQ 0x0d0c0b0a090807060504030201008f8e # shl 2  (16-14) / shr14
 649 #       DDQ 0x0e0d0c0b0a090807060504030201008f # shl 1  (16-15) / shr15
 650 .octa 0x8f8e8d8c8b8a89888786858483828100
 651 .octa 0x000e0d0c0b0a09080706050403020100