arch/x86/crypto/aesni-intel_avx-x86_64.S

   1 ########################################################################
   2 # Copyright (c) 2013, Intel Corporation
   3 #
   4 # This software is available to you under a choice of one of two
   5 # licenses.  You may choose to be licensed under the terms of the GNU
   6 # General Public License (GPL) Version 2, available from the file
   7 # COPYING in the main directory of this source tree, or the
   8 # OpenIB.org BSD license below:
   9 #
  10 # Redistribution and use in source and binary forms, with or without
  11 # modification, are permitted provided that the following conditions are
  12 # met:
  13 #
  14 # * Redistributions of source code must retain the above copyright
  15 #   notice, this list of conditions and the following disclaimer.
  16 #
  17 # * Redistributions in binary form must reproduce the above copyright
  18 #   notice, this list of conditions and the following disclaimer in the
  19 #   documentation and/or other materials provided with the
  20 #   distribution.
  21 #
  22 # * Neither the name of the Intel Corporation nor the names of its
  23 #   contributors may be used to endorse or promote products derived from
  24 #   this software without specific prior written permission.
  25 #
  26 #
  27 # THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY
  28 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  30 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR
  31 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  32 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  33 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES# LOSS OF USE, DATA, OR
  34 # PROFITS# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  35 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  36 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  37 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38 ########################################################################
  39 ##
  40 ## Authors:
  41 ##      Erdinc Ozturk <erdinc.ozturk@intel.com>
  42 ##      Vinodh Gopal <vinodh.gopal@intel.com>
  43 ##      James Guilford <james.guilford@intel.com>
  44 ##      Tim Chen <tim.c.chen@linux.intel.com>
  45 ##
  46 ## References:
  47 ##       This code was derived and highly optimized from the code described in paper:
  48 ##               Vinodh Gopal et. al. Optimized Galois-Counter-Mode Implementation
  49 ##                      on Intel Architecture Processors. August, 2010
  50 ##       The details of the implementation is explained in:
  51 ##               Erdinc Ozturk et. al. Enabling High-Performance Galois-Counter-Mode
  52 ##                      on Intel Architecture Processors. October, 2012.
  53 ##
  54 ## Assumptions:
  55 ##
  56 ##
  57 ##
  58 ## iv:
  59 ##       0                   1                   2                   3
  60 ##       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  61 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  62 ##       |                             Salt  (From the SA)               |
  63 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  64 ##       |                     Initialization Vector                     |
  65 ##       |         (This is the sequence number from IPSec header)       |
  66 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  67 ##       |                              0x1                              |
  68 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  69 ##
  70 ##
  71 ##
  72 ## AAD:
  73 ##       AAD padded to 128 bits with 0
  74 ##       for example, assume AAD is a u32 vector
  75 ##
  76 ##       if AAD is 8 bytes:
  77 ##       AAD[3] = {A0, A1}#
  78 ##       padded AAD in xmm register = {A1 A0 0 0}
  79 ##
  80 ##       0                   1                   2                   3
  81 ##       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  82 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  83 ##       |                               SPI (A1)                        |
  84 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  85 ##       |                     32-bit Sequence Number (A0)               |
  86 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  87 ##       |                              0x0                              |
  88 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  89 ##
  90 ##                                       AAD Format with 32-bit Sequence Number
  91 ##
  92 ##       if AAD is 12 bytes:
  93 ##       AAD[3] = {A0, A1, A2}#
  94 ##       padded AAD in xmm register = {A2 A1 A0 0}
  95 ##
  96 ##       0                   1                   2                   3
  97 ##       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  98 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  99 ##       |                               SPI (A2)                        |
 100 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 101 ##       |                 64-bit Extended Sequence Number {A1,A0}       |
 102 ##       |                                                               |
 103 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 104 ##       |                              0x0                              |
 105 ##       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 106 ##
 107 ##        AAD Format with 64-bit Extended Sequence Number
 108 ##
 109 ##
 110 ## aadLen:
 111 ##       from the definition of the spec, aadLen can only be 8 or 12 bytes.
 112 ##       The code additionally supports aadLen of length 16 bytes.
 113 ##
 114 ## TLen:
 115 ##       from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
 116 ##
 117 ## poly = x^128 + x^127 + x^126 + x^121 + 1
 118 ## throughout the code, one tab and two tab indentations are used. one tab is
 119 ## for GHASH part, two tabs is for AES part.
 120 ##
 121
 122 #include <linux/linkage.h>
 123 #include <asm/inst.h>
 124
 125 # constants in mergeable sections, linker can reorder and merge
 126 .section        .rodata.cst16.POLY, "aM", @progbits, 16
 127 .align 16
 128 POLY:            .octa     0xC2000000000000000000000000000001
 129
 130 .section        .rodata.cst16.POLY2, "aM", @progbits, 16
 131 .align 16
 132 POLY2:           .octa     0xC20000000000000000000001C2000000
 133
 134 .section        .rodata.cst16.TWOONE, "aM", @progbits, 16
 135 .align 16
 136 TWOONE:          .octa     0x00000001000000000000000000000001
 137
 138 .section        .rodata.cst16.SHUF_MASK, "aM", @progbits, 16
 139 .align 16
 140 SHUF_MASK:       .octa     0x000102030405060708090A0B0C0D0E0F
 141
 142 .section        .rodata.cst16.ONE, "aM", @progbits, 16
 143 .align 16
 144 ONE:             .octa     0x00000000000000000000000000000001
 145
 146 .section        .rodata.cst16.ONEf, "aM", @progbits, 16
 147 .align 16
 148 ONEf:            .octa     0x01000000000000000000000000000000
 149
 150 # order of these constants should not change.
 151 # more specifically, ALL_F should follow SHIFT_MASK, and zero should follow ALL_F
 152 .section        .rodata, "a", @progbits
 153 .align 16
 154 SHIFT_MASK:      .octa     0x0f0e0d0c0b0a09080706050403020100
 155 ALL_F:           .octa     0xffffffffffffffffffffffffffffffff
 156                  .octa     0x00000000000000000000000000000000
 157
 158 .section .rodata
 159 .align 16
 160 .type aad_shift_arr, @object
 161 .size aad_shift_arr, 272
 162 aad_shift_arr:
 163         .octa     0xffffffffffffffffffffffffffffffff
 164         .octa     0xffffffffffffffffffffffffffffff0C
 165         .octa     0xffffffffffffffffffffffffffff0D0C
 166         .octa     0xffffffffffffffffffffffffff0E0D0C
 167         .octa     0xffffffffffffffffffffffff0F0E0D0C
 168         .octa     0xffffffffffffffffffffff0C0B0A0908
 169         .octa     0xffffffffffffffffffff0D0C0B0A0908
 170         .octa     0xffffffffffffffffff0E0D0C0B0A0908
 171         .octa     0xffffffffffffffff0F0E0D0C0B0A0908
 172         .octa     0xffffffffffffff0C0B0A090807060504
 173         .octa     0xffffffffffff0D0C0B0A090807060504
 174         .octa     0xffffffffff0E0D0C0B0A090807060504
 175         .octa     0xffffffff0F0E0D0C0B0A090807060504
 176         .octa     0xffffff0C0B0A09080706050403020100
 177         .octa     0xffff0D0C0B0A09080706050403020100
 178         .octa     0xff0E0D0C0B0A09080706050403020100
 179         .octa     0x0F0E0D0C0B0A09080706050403020100
 180
 181
 182 .text
 183
 184
 185 HashKey        = 16*6   # store HashKey <<1 mod poly here
 186 HashKey_2      = 16*7   # store HashKey^2 <<1 mod poly here
 187 HashKey_3      = 16*8   # store HashKey^3 <<1 mod poly here
 188 HashKey_4      = 16*9   # store HashKey^4 <<1 mod poly here
 189 HashKey_5      = 16*10   # store HashKey^5 <<1 mod poly here
 190 HashKey_6      = 16*11   # store HashKey^6 <<1 mod poly here
 191 HashKey_7      = 16*12   # store HashKey^7 <<1 mod poly here
 192 HashKey_8      = 16*13   # store HashKey^8 <<1 mod poly here
 193 HashKey_k      = 16*14   # store XOR of HashKey <<1 mod poly here (for Karatsuba purposes)
 194 HashKey_2_k    = 16*15   # store XOR of HashKey^2 <<1 mod poly here (for Karatsuba purposes)
 195 HashKey_3_k    = 16*16   # store XOR of HashKey^3 <<1 mod poly here (for Karatsuba purposes)
 196 HashKey_4_k    = 16*17   # store XOR of HashKey^4 <<1 mod poly here (for Karatsuba purposes)
 197 HashKey_5_k    = 16*18   # store XOR of HashKey^5 <<1 mod poly here (for Karatsuba purposes)
 198 HashKey_6_k    = 16*19   # store XOR of HashKey^6 <<1 mod poly here (for Karatsuba purposes)
 199 HashKey_7_k    = 16*20   # store XOR of HashKey^7 <<1 mod poly here (for Karatsuba purposes)
 200 HashKey_8_k    = 16*21   # store XOR of HashKey^8 <<1 mod poly here (for Karatsuba purposes)
 201
 202 #define arg1 %rdi
 203 #define arg2 %rsi
 204 #define arg3 %rdx
 205 #define arg4 %rcx
 206 #define arg5 %r8
 207 #define arg6 %r9
 208 #define arg7 STACK_OFFSET+8*1(%r14)
 209 #define arg8 STACK_OFFSET+8*2(%r14)
 210 #define arg9 STACK_OFFSET+8*3(%r14)
 211 #define arg10 STACK_OFFSET+8*4(%r14)
 212
 213 i = 0
 214 j = 0
 215
 216 out_order = 0
 217 in_order = 1
 218 DEC = 0
 219 ENC = 1
 220
 221 .macro define_reg r n
 222 reg_\r = %xmm\n
 223 .endm
 224
 225 .macro setreg
 226 .altmacro
 227 define_reg i %i
 228 define_reg j %j
 229 .noaltmacro
 230 .endm
 231
 232 # need to push 4 registers into stack to maintain
 233 STACK_OFFSET = 8*4
 234
 235 TMP1 =   16*0    # Temporary storage for AAD
 236 TMP2 =   16*1    # Temporary storage for AES State 2 (State 1 is stored in an XMM register)
 237 TMP3 =   16*2    # Temporary storage for AES State 3
 238 TMP4 =   16*3    # Temporary storage for AES State 4
 239 TMP5 =   16*4    # Temporary storage for AES State 5
 240 TMP6 =   16*5    # Temporary storage for AES State 6
 241 TMP7 =   16*6    # Temporary storage for AES State 7
 242 TMP8 =   16*7    # Temporary storage for AES State 8
 243
 244 VARIABLE_OFFSET = 16*8
 245
 246 ################################
 247 # Utility Macros
 248 ################################
 249
 250 .macro FUNC_SAVE
 251         #the number of pushes must equal STACK_OFFSET
 252         push    %r12
 253         push    %r13
 254         push    %r14
 255         push    %r15
 256
 257         mov     %rsp, %r14
 258
 259
 260
 261         sub     $VARIABLE_OFFSET, %rsp
 262         and     $~63, %rsp                    # align rsp to 64 bytes
 263 .endm
 264
 265 .macro FUNC_RESTORE
 266         mov     %r14, %rsp
 267
 268         pop     %r15
 269         pop     %r14
 270         pop     %r13
 271         pop     %r12
 272 .endm
 273
 274 # Encryption of a single block
 275 .macro ENCRYPT_SINGLE_BLOCK XMM0
 276                 vpxor    (arg1), \XMM0, \XMM0
 277                 i = 1
 278                 setreg
 279 .rep 9
 280                 vaesenc  16*i(arg1), \XMM0, \XMM0
 281                 i = (i+1)
 282                 setreg
 283 .endr
 284                 vaesenclast 16*10(arg1), \XMM0, \XMM0
 285 .endm
 286
 287 # combined for GCM encrypt and decrypt functions
 288 # clobbering all xmm registers
 289 # clobbering r10, r11, r12, r13, r14, r15
 290 .macro  GCM_ENC_DEC INITIAL_BLOCKS GHASH_8_ENCRYPT_8_PARALLEL GHASH_LAST_8 GHASH_MUL ENC_DEC
 291         vmovdqu  HashKey(arg2), %xmm13      # xmm13 = HashKey
 292
 293         mov     arg5, %r13                  # save the number of bytes of plaintext/ciphertext
 294         and     $-16, %r13                  # r13 = r13 - (r13 mod 16)
 295
 296         mov     %r13, %r12
 297         shr     $4, %r12
 298         and     $7, %r12
 299         jz      _initial_num_blocks_is_0\@
 300
 301         cmp     $7, %r12
 302         je      _initial_num_blocks_is_7\@
 303         cmp     $6, %r12
 304         je      _initial_num_blocks_is_6\@
 305         cmp     $5, %r12
 306         je      _initial_num_blocks_is_5\@
 307         cmp     $4, %r12
 308         je      _initial_num_blocks_is_4\@
 309         cmp     $3, %r12
 310         je      _initial_num_blocks_is_3\@
 311         cmp     $2, %r12
 312         je      _initial_num_blocks_is_2\@
 313
 314         jmp     _initial_num_blocks_is_1\@
 315
 316 _initial_num_blocks_is_7\@:
 317         \INITIAL_BLOCKS  7, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 318         sub     $16*7, %r13
 319         jmp     _initial_blocks_encrypted\@
 320
 321 _initial_num_blocks_is_6\@:
 322         \INITIAL_BLOCKS  6, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 323         sub     $16*6, %r13
 324         jmp     _initial_blocks_encrypted\@
 325
 326 _initial_num_blocks_is_5\@:
 327         \INITIAL_BLOCKS  5, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 328         sub     $16*5, %r13
 329         jmp     _initial_blocks_encrypted\@
 330
 331 _initial_num_blocks_is_4\@:
 332         \INITIAL_BLOCKS  4, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 333         sub     $16*4, %r13
 334         jmp     _initial_blocks_encrypted\@
 335
 336 _initial_num_blocks_is_3\@:
 337         \INITIAL_BLOCKS  3, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 338         sub     $16*3, %r13
 339         jmp     _initial_blocks_encrypted\@
 340
 341 _initial_num_blocks_is_2\@:
 342         \INITIAL_BLOCKS  2, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 343         sub     $16*2, %r13
 344         jmp     _initial_blocks_encrypted\@
 345
 346 _initial_num_blocks_is_1\@:
 347         \INITIAL_BLOCKS  1, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 348         sub     $16*1, %r13
 349         jmp     _initial_blocks_encrypted\@
 350
 351 _initial_num_blocks_is_0\@:
 352         \INITIAL_BLOCKS  0, %xmm12, %xmm13, %xmm14, %xmm15, %xmm11, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm10, %xmm0, \ENC_DEC
 353
 354
 355 _initial_blocks_encrypted\@:
 356         cmp     $0, %r13
 357         je      _zero_cipher_left\@
 358
 359         sub     $128, %r13
 360         je      _eight_cipher_left\@
 361
 362
 363
 364
 365         vmovd   %xmm9, %r15d
 366         and     $255, %r15d
 367         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 368
 369
 370 _encrypt_by_8_new\@:
 371         cmp     $(255-8), %r15d
 372         jg      _encrypt_by_8\@
 373
 374
 375
 376         add     $8, %r15b
 377         \GHASH_8_ENCRYPT_8_PARALLEL      %xmm0, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm15, out_order, \ENC_DEC
 378         add     $128, %r11
 379         sub     $128, %r13
 380         jne     _encrypt_by_8_new\@
 381
 382         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 383         jmp     _eight_cipher_left\@
 384
 385 _encrypt_by_8\@:
 386         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 387         add     $8, %r15b
 388         \GHASH_8_ENCRYPT_8_PARALLEL      %xmm0, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, %xmm9, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, %xmm15, in_order, \ENC_DEC
 389         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 390         add     $128, %r11
 391         sub     $128, %r13
 392         jne     _encrypt_by_8_new\@
 393
 394         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 395
 396
 397
 398
 399 _eight_cipher_left\@:
 400         \GHASH_LAST_8    %xmm0, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8
 401
 402
 403 _zero_cipher_left\@:
 404         cmp     $16, arg5
 405         jl      _only_less_than_16\@
 406
 407         mov     arg5, %r13
 408         and     $15, %r13                            # r13 = (arg5 mod 16)
 409
 410         je      _multiple_of_16_bytes\@
 411
 412         # handle the last <16 Byte block seperately
 413
 414
 415         vpaddd   ONE(%rip), %xmm9, %xmm9             # INCR CNT to get Yn
 416         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 417         ENCRYPT_SINGLE_BLOCK    %xmm9                # E(K, Yn)
 418
 419         sub     $16, %r11
 420         add     %r13, %r11
 421         vmovdqu (arg4, %r11), %xmm1                  # receive the last <16 Byte block
 422
 423         lea     SHIFT_MASK+16(%rip), %r12
 424         sub     %r13, %r12                           # adjust the shuffle mask pointer to be
 425                                                      # able to shift 16-r13 bytes (r13 is the
 426                                                      # number of bytes in plaintext mod 16)
 427         vmovdqu (%r12), %xmm2                        # get the appropriate shuffle mask
 428         vpshufb %xmm2, %xmm1, %xmm1                  # shift right 16-r13 bytes
 429         jmp     _final_ghash_mul\@
 430
 431 _only_less_than_16\@:
 432         # check for 0 length
 433         mov     arg5, %r13
 434         and     $15, %r13                            # r13 = (arg5 mod 16)
 435
 436         je      _multiple_of_16_bytes\@
 437
 438         # handle the last <16 Byte block separately
 439
 440
 441         vpaddd  ONE(%rip), %xmm9, %xmm9              # INCR CNT to get Yn
 442         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 443         ENCRYPT_SINGLE_BLOCK    %xmm9                # E(K, Yn)
 444
 445
 446         lea     SHIFT_MASK+16(%rip), %r12
 447         sub     %r13, %r12                           # adjust the shuffle mask pointer to be
 448                                                      # able to shift 16-r13 bytes (r13 is the
 449                                                      # number of bytes in plaintext mod 16)
 450
 451 _get_last_16_byte_loop\@:
 452         movb    (arg4, %r11),  %al
 453         movb    %al,  TMP1 (%rsp , %r11)
 454         add     $1, %r11
 455         cmp     %r13,  %r11
 456         jne     _get_last_16_byte_loop\@
 457
 458         vmovdqu  TMP1(%rsp), %xmm1
 459
 460         sub     $16, %r11
 461
 462 _final_ghash_mul\@:
 463         .if  \ENC_DEC ==  DEC
 464         vmovdqa %xmm1, %xmm2
 465         vpxor   %xmm1, %xmm9, %xmm9                  # Plaintext XOR E(K, Yn)
 466         vmovdqu ALL_F-SHIFT_MASK(%r12), %xmm1        # get the appropriate mask to
 467                                                      # mask out top 16-r13 bytes of xmm9
 468         vpand   %xmm1, %xmm9, %xmm9                  # mask out top 16-r13 bytes of xmm9
 469         vpand   %xmm1, %xmm2, %xmm2
 470         vpshufb SHUF_MASK(%rip), %xmm2, %xmm2
 471         vpxor   %xmm2, %xmm14, %xmm14
 472         #GHASH computation for the last <16 Byte block
 473         \GHASH_MUL       %xmm14, %xmm13, %xmm0, %xmm10, %xmm11, %xmm5, %xmm6
 474         sub     %r13, %r11
 475         add     $16, %r11
 476         .else
 477         vpxor   %xmm1, %xmm9, %xmm9                  # Plaintext XOR E(K, Yn)
 478         vmovdqu ALL_F-SHIFT_MASK(%r12), %xmm1        # get the appropriate mask to
 479                                                      # mask out top 16-r13 bytes of xmm9
 480         vpand   %xmm1, %xmm9, %xmm9                  # mask out top 16-r13 bytes of xmm9
 481         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9
 482         vpxor   %xmm9, %xmm14, %xmm14
 483         #GHASH computation for the last <16 Byte block
 484         \GHASH_MUL       %xmm14, %xmm13, %xmm0, %xmm10, %xmm11, %xmm5, %xmm6
 485         sub     %r13, %r11
 486         add     $16, %r11
 487         vpshufb SHUF_MASK(%rip), %xmm9, %xmm9        # shuffle xmm9 back to output as ciphertext
 488         .endif
 489
 490
 491         #############################
 492         # output r13 Bytes
 493         vmovq   %xmm9, %rax
 494         cmp     $8, %r13
 495         jle     _less_than_8_bytes_left\@
 496
 497         mov     %rax, (arg3 , %r11)
 498         add     $8, %r11
 499         vpsrldq $8, %xmm9, %xmm9
 500         vmovq   %xmm9, %rax
 501         sub     $8, %r13
 502
 503 _less_than_8_bytes_left\@:
 504         movb    %al, (arg3 , %r11)
 505         add     $1, %r11
 506         shr     $8, %rax
 507         sub     $1, %r13
 508         jne     _less_than_8_bytes_left\@
 509         #############################
 510
 511 _multiple_of_16_bytes\@:
 512         mov     arg8, %r12                           # r12 = aadLen (number of bytes)
 513         shl     $3, %r12                             # convert into number of bits
 514         vmovd   %r12d, %xmm15                        # len(A) in xmm15
 515
 516         shl     $3, arg5                             # len(C) in bits  (*128)
 517         vmovq   arg5, %xmm1
 518         vpslldq $8, %xmm15, %xmm15                   # xmm15 = len(A)|| 0x0000000000000000
 519         vpxor   %xmm1, %xmm15, %xmm15                # xmm15 = len(A)||len(C)
 520
 521         vpxor   %xmm15, %xmm14, %xmm14
 522         \GHASH_MUL       %xmm14, %xmm13, %xmm0, %xmm10, %xmm11, %xmm5, %xmm6    # final GHASH computation
 523         vpshufb SHUF_MASK(%rip), %xmm14, %xmm14      # perform a 16Byte swap
 524
 525         mov     arg6, %rax                           # rax = *Y0
 526         vmovdqu (%rax), %xmm9                        # xmm9 = Y0
 527
 528         ENCRYPT_SINGLE_BLOCK    %xmm9                # E(K, Y0)
 529
 530         vpxor   %xmm14, %xmm9, %xmm9
 531
 532
 533
 534 _return_T\@:
 535         mov     arg9, %r10              # r10 = authTag
 536         mov     arg10, %r11              # r11 = auth_tag_len
 537
 538         cmp     $16, %r11
 539         je      _T_16\@
 540
 541         cmp     $8, %r11
 542         jl      _T_4\@
 543
 544 _T_8\@:
 545         vmovq   %xmm9, %rax
 546         mov     %rax, (%r10)
 547         add     $8, %r10
 548         sub     $8, %r11
 549         vpsrldq $8, %xmm9, %xmm9
 550         cmp     $0, %r11
 551         je     _return_T_done\@
 552 _T_4\@:
 553         vmovd   %xmm9, %eax
 554         mov     %eax, (%r10)
 555         add     $4, %r10
 556         sub     $4, %r11
 557         vpsrldq     $4, %xmm9, %xmm9
 558         cmp     $0, %r11
 559         je     _return_T_done\@
 560 _T_123\@:
 561         vmovd     %xmm9, %eax
 562         cmp     $2, %r11
 563         jl     _T_1\@
 564         mov     %ax, (%r10)
 565         cmp     $2, %r11
 566         je     _return_T_done\@
 567         add     $2, %r10
 568         sar     $16, %eax
 569 _T_1\@:
 570         mov     %al, (%r10)
 571         jmp     _return_T_done\@
 572
 573 _T_16\@:
 574         vmovdqu %xmm9, (%r10)
 575
 576 _return_T_done\@:
 577 .endm
 578
 579 #ifdef CONFIG_AS_AVX
 580 ###############################################################################
 581 # GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
 582 # Input: A and B (128-bits each, bit-reflected)
 583 # Output: C = A*B*x mod poly, (i.e. >>1 )
 584 # To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
 585 # GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
 586 ###############################################################################
 587 .macro  GHASH_MUL_AVX GH HK T1 T2 T3 T4 T5
 588
 589         vpshufd         $0b01001110, \GH, \T2
 590         vpshufd         $0b01001110, \HK, \T3
 591         vpxor           \GH     , \T2, \T2      # T2 = (a1+a0)
 592         vpxor           \HK     , \T3, \T3      # T3 = (b1+b0)
 593
 594         vpclmulqdq      $0x11, \HK, \GH, \T1    # T1 = a1*b1
 595         vpclmulqdq      $0x00, \HK, \GH, \GH    # GH = a0*b0
 596         vpclmulqdq      $0x00, \T3, \T2, \T2    # T2 = (a1+a0)*(b1+b0)
 597         vpxor           \GH, \T2,\T2
 598         vpxor           \T1, \T2,\T2            # T2 = a0*b1+a1*b0
 599
 600         vpslldq         $8, \T2,\T3             # shift-L T3 2 DWs
 601         vpsrldq         $8, \T2,\T2             # shift-R T2 2 DWs
 602         vpxor           \T3, \GH, \GH
 603         vpxor           \T2, \T1, \T1           # <T1:GH> = GH x HK
 604
 605         #first phase of the reduction
 606         vpslld  $31, \GH, \T2                   # packed right shifting << 31
 607         vpslld  $30, \GH, \T3                   # packed right shifting shift << 30
 608         vpslld  $25, \GH, \T4                   # packed right shifting shift << 25
 609
 610         vpxor   \T3, \T2, \T2                   # xor the shifted versions
 611         vpxor   \T4, \T2, \T2
 612
 613         vpsrldq $4, \T2, \T5                    # shift-R T5 1 DW
 614
 615         vpslldq $12, \T2, \T2                   # shift-L T2 3 DWs
 616         vpxor   \T2, \GH, \GH                   # first phase of the reduction complete
 617
 618         #second phase of the reduction
 619
 620         vpsrld  $1,\GH, \T2                     # packed left shifting >> 1
 621         vpsrld  $2,\GH, \T3                     # packed left shifting >> 2
 622         vpsrld  $7,\GH, \T4                     # packed left shifting >> 7
 623         vpxor   \T3, \T2, \T2                   # xor the shifted versions
 624         vpxor   \T4, \T2, \T2
 625
 626         vpxor   \T5, \T2, \T2
 627         vpxor   \T2, \GH, \GH
 628         vpxor   \T1, \GH, \GH                   # the result is in GH
 629
 630
 631 .endm
 632
 633 .macro PRECOMPUTE_AVX HK T1 T2 T3 T4 T5 T6
 634
 635         # Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
 636         vmovdqa  \HK, \T5
 637
 638         vpshufd  $0b01001110, \T5, \T1
 639         vpxor    \T5, \T1, \T1
 640         vmovdqu  \T1, HashKey_k(arg2)
 641
 642         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^2<<1 mod poly
 643         vmovdqu  \T5, HashKey_2(arg2)                    #  [HashKey_2] = HashKey^2<<1 mod poly
 644         vpshufd  $0b01001110, \T5, \T1
 645         vpxor    \T5, \T1, \T1
 646         vmovdqu  \T1, HashKey_2_k(arg2)
 647
 648         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^3<<1 mod poly
 649         vmovdqu  \T5, HashKey_3(arg2)
 650         vpshufd  $0b01001110, \T5, \T1
 651         vpxor    \T5, \T1, \T1
 652         vmovdqu  \T1, HashKey_3_k(arg2)
 653
 654         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^4<<1 mod poly
 655         vmovdqu  \T5, HashKey_4(arg2)
 656         vpshufd  $0b01001110, \T5, \T1
 657         vpxor    \T5, \T1, \T1
 658         vmovdqu  \T1, HashKey_4_k(arg2)
 659
 660         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^5<<1 mod poly
 661         vmovdqu  \T5, HashKey_5(arg2)
 662         vpshufd  $0b01001110, \T5, \T1
 663         vpxor    \T5, \T1, \T1
 664         vmovdqu  \T1, HashKey_5_k(arg2)
 665
 666         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^6<<1 mod poly
 667         vmovdqu  \T5, HashKey_6(arg2)
 668         vpshufd  $0b01001110, \T5, \T1
 669         vpxor    \T5, \T1, \T1
 670         vmovdqu  \T1, HashKey_6_k(arg2)
 671
 672         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^7<<1 mod poly
 673         vmovdqu  \T5, HashKey_7(arg2)
 674         vpshufd  $0b01001110, \T5, \T1
 675         vpxor    \T5, \T1, \T1
 676         vmovdqu  \T1, HashKey_7_k(arg2)
 677
 678         GHASH_MUL_AVX \T5, \HK, \T1, \T3, \T4, \T6, \T2  #  T5 = HashKey^8<<1 mod poly
 679         vmovdqu  \T5, HashKey_8(arg2)
 680         vpshufd  $0b01001110, \T5, \T1
 681         vpxor    \T5, \T1, \T1
 682         vmovdqu  \T1, HashKey_8_k(arg2)
 683
 684 .endm
 685
 686 ## if a = number of total plaintext bytes
 687 ## b = floor(a/16)
 688 ## num_initial_blocks = b mod 4#
 689 ## encrypt the initial num_initial_blocks blocks and apply ghash on the ciphertext
 690 ## r10, r11, r12, rax are clobbered
 691 ## arg1, arg3, arg4, r14 are used as a pointer only, not modified
 692
 693 .macro INITIAL_BLOCKS_AVX num_initial_blocks T1 T2 T3 T4 T5 CTR XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 T6 T_key ENC_DEC
 694         i = (8-\num_initial_blocks)
 695         j = 0
 696         setreg
 697
 698         mov     arg7, %r10                      # r10 = AAD
 699         mov     arg8, %r12                      # r12 = aadLen
 700
 701
 702         mov     %r12, %r11
 703
 704         vpxor   reg_j, reg_j, reg_j
 705         vpxor   reg_i, reg_i, reg_i
 706         cmp     $16, %r11
 707         jl      _get_AAD_rest8\@
 708 _get_AAD_blocks\@:
 709         vmovdqu (%r10), reg_i
 710         vpshufb SHUF_MASK(%rip), reg_i, reg_i
 711         vpxor   reg_i, reg_j, reg_j
 712         GHASH_MUL_AVX       reg_j, \T2, \T1, \T3, \T4, \T5, \T6
 713         add     $16, %r10
 714         sub     $16, %r12
 715         sub     $16, %r11
 716         cmp     $16, %r11
 717         jge     _get_AAD_blocks\@
 718         vmovdqu reg_j, reg_i
 719         cmp     $0, %r11
 720         je      _get_AAD_done\@
 721
 722         vpxor   reg_i, reg_i, reg_i
 723
 724         /* read the last <16B of AAD. since we have at least 4B of
 725         data right after the AAD (the ICV, and maybe some CT), we can
 726         read 4B/8B blocks safely, and then get rid of the extra stuff */
 727 _get_AAD_rest8\@:
 728         cmp     $4, %r11
 729         jle     _get_AAD_rest4\@
 730         movq    (%r10), \T1
 731         add     $8, %r10
 732         sub     $8, %r11
 733         vpslldq $8, \T1, \T1
 734         vpsrldq $8, reg_i, reg_i
 735         vpxor   \T1, reg_i, reg_i
 736         jmp     _get_AAD_rest8\@
 737 _get_AAD_rest4\@:
 738         cmp     $0, %r11
 739         jle      _get_AAD_rest0\@
 740         mov     (%r10), %eax
 741         movq    %rax, \T1
 742         add     $4, %r10
 743         sub     $4, %r11
 744         vpslldq $12, \T1, \T1
 745         vpsrldq $4, reg_i, reg_i
 746         vpxor   \T1, reg_i, reg_i
 747 _get_AAD_rest0\@:
 748         /* finalize: shift out the extra bytes we read, and align
 749         left. since pslldq can only shift by an immediate, we use
 750         vpshufb and an array of shuffle masks */
 751         movq    %r12, %r11
 752         salq    $4, %r11
 753         movdqu  aad_shift_arr(%r11), \T1
 754         vpshufb \T1, reg_i, reg_i
 755 _get_AAD_rest_final\@:
 756         vpshufb SHUF_MASK(%rip), reg_i, reg_i
 757         vpxor   reg_j, reg_i, reg_i
 758         GHASH_MUL_AVX       reg_i, \T2, \T1, \T3, \T4, \T5, \T6
 759
 760 _get_AAD_done\@:
 761         # initialize the data pointer offset as zero
 762         xor     %r11d, %r11d
 763
 764         # start AES for num_initial_blocks blocks
 765         mov     arg6, %rax                     # rax = *Y0
 766         vmovdqu (%rax), \CTR                   # CTR = Y0
 767         vpshufb SHUF_MASK(%rip), \CTR, \CTR
 768
 769
 770         i = (9-\num_initial_blocks)
 771         setreg
 772 .rep \num_initial_blocks
 773                 vpaddd  ONE(%rip), \CTR, \CTR           # INCR Y0
 774                 vmovdqa \CTR, reg_i
 775                 vpshufb SHUF_MASK(%rip), reg_i, reg_i   # perform a 16Byte swap
 776         i = (i+1)
 777         setreg
 778 .endr
 779
 780         vmovdqa  (arg1), \T_key
 781         i = (9-\num_initial_blocks)
 782         setreg
 783 .rep \num_initial_blocks
 784                 vpxor   \T_key, reg_i, reg_i
 785         i = (i+1)
 786         setreg
 787 .endr
 788
 789         j = 1
 790         setreg
 791 .rep 9
 792         vmovdqa  16*j(arg1), \T_key
 793         i = (9-\num_initial_blocks)
 794         setreg
 795 .rep \num_initial_blocks
 796         vaesenc \T_key, reg_i, reg_i
 797         i = (i+1)
 798         setreg
 799 .endr
 800
 801         j = (j+1)
 802         setreg
 803 .endr
 804
 805
 806         vmovdqa  16*10(arg1), \T_key
 807         i = (9-\num_initial_blocks)
 808         setreg
 809 .rep \num_initial_blocks
 810         vaesenclast      \T_key, reg_i, reg_i
 811         i = (i+1)
 812         setreg
 813 .endr
 814
 815         i = (9-\num_initial_blocks)
 816         setreg
 817 .rep \num_initial_blocks
 818                 vmovdqu (arg4, %r11), \T1
 819                 vpxor   \T1, reg_i, reg_i
 820                 vmovdqu reg_i, (arg3 , %r11)           # write back ciphertext for num_initial_blocks blocks
 821                 add     $16, %r11
 822 .if  \ENC_DEC == DEC
 823                 vmovdqa \T1, reg_i
 824 .endif
 825                 vpshufb SHUF_MASK(%rip), reg_i, reg_i  # prepare ciphertext for GHASH computations
 826         i = (i+1)
 827         setreg
 828 .endr
 829
 830
 831         i = (8-\num_initial_blocks)
 832         j = (9-\num_initial_blocks)
 833         setreg
 834
 835 .rep \num_initial_blocks
 836         vpxor    reg_i, reg_j, reg_j
 837         GHASH_MUL_AVX       reg_j, \T2, \T1, \T3, \T4, \T5, \T6 # apply GHASH on num_initial_blocks blocks
 838         i = (i+1)
 839         j = (j+1)
 840         setreg
 841 .endr
 842         # XMM8 has the combined result here
 843
 844         vmovdqa  \XMM8, TMP1(%rsp)
 845         vmovdqa  \XMM8, \T3
 846
 847         cmp     $128, %r13
 848         jl      _initial_blocks_done\@                  # no need for precomputed constants
 849
 850 ###############################################################################
 851 # Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
 852                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 853                 vmovdqa  \CTR, \XMM1
 854                 vpshufb  SHUF_MASK(%rip), \XMM1, \XMM1  # perform a 16Byte swap
 855
 856                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 857                 vmovdqa  \CTR, \XMM2
 858                 vpshufb  SHUF_MASK(%rip), \XMM2, \XMM2  # perform a 16Byte swap
 859
 860                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 861                 vmovdqa  \CTR, \XMM3
 862                 vpshufb  SHUF_MASK(%rip), \XMM3, \XMM3  # perform a 16Byte swap
 863
 864                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 865                 vmovdqa  \CTR, \XMM4
 866                 vpshufb  SHUF_MASK(%rip), \XMM4, \XMM4  # perform a 16Byte swap
 867
 868                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 869                 vmovdqa  \CTR, \XMM5
 870                 vpshufb  SHUF_MASK(%rip), \XMM5, \XMM5  # perform a 16Byte swap
 871
 872                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 873                 vmovdqa  \CTR, \XMM6
 874                 vpshufb  SHUF_MASK(%rip), \XMM6, \XMM6  # perform a 16Byte swap
 875
 876                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 877                 vmovdqa  \CTR, \XMM7
 878                 vpshufb  SHUF_MASK(%rip), \XMM7, \XMM7  # perform a 16Byte swap
 879
 880                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
 881                 vmovdqa  \CTR, \XMM8
 882                 vpshufb  SHUF_MASK(%rip), \XMM8, \XMM8  # perform a 16Byte swap
 883
 884                 vmovdqa  (arg1), \T_key
 885                 vpxor    \T_key, \XMM1, \XMM1
 886                 vpxor    \T_key, \XMM2, \XMM2
 887                 vpxor    \T_key, \XMM3, \XMM3
 888                 vpxor    \T_key, \XMM4, \XMM4
 889                 vpxor    \T_key, \XMM5, \XMM5
 890                 vpxor    \T_key, \XMM6, \XMM6
 891                 vpxor    \T_key, \XMM7, \XMM7
 892                 vpxor    \T_key, \XMM8, \XMM8
 893
 894                 i = 1
 895                 setreg
 896 .rep    9       # do 9 rounds
 897                 vmovdqa  16*i(arg1), \T_key
 898                 vaesenc  \T_key, \XMM1, \XMM1
 899                 vaesenc  \T_key, \XMM2, \XMM2
 900                 vaesenc  \T_key, \XMM3, \XMM3
 901                 vaesenc  \T_key, \XMM4, \XMM4
 902                 vaesenc  \T_key, \XMM5, \XMM5
 903                 vaesenc  \T_key, \XMM6, \XMM6
 904                 vaesenc  \T_key, \XMM7, \XMM7
 905                 vaesenc  \T_key, \XMM8, \XMM8
 906                 i = (i+1)
 907                 setreg
 908 .endr
 909
 910
 911                 vmovdqa  16*i(arg1), \T_key
 912                 vaesenclast  \T_key, \XMM1, \XMM1
 913                 vaesenclast  \T_key, \XMM2, \XMM2
 914                 vaesenclast  \T_key, \XMM3, \XMM3
 915                 vaesenclast  \T_key, \XMM4, \XMM4
 916                 vaesenclast  \T_key, \XMM5, \XMM5
 917                 vaesenclast  \T_key, \XMM6, \XMM6
 918                 vaesenclast  \T_key, \XMM7, \XMM7
 919                 vaesenclast  \T_key, \XMM8, \XMM8
 920
 921                 vmovdqu  (arg4, %r11), \T1
 922                 vpxor    \T1, \XMM1, \XMM1
 923                 vmovdqu  \XMM1, (arg3 , %r11)
 924                 .if   \ENC_DEC == DEC
 925                 vmovdqa  \T1, \XMM1
 926                 .endif
 927
 928                 vmovdqu  16*1(arg4, %r11), \T1
 929                 vpxor    \T1, \XMM2, \XMM2
 930                 vmovdqu  \XMM2, 16*1(arg3 , %r11)
 931                 .if   \ENC_DEC == DEC
 932                 vmovdqa  \T1, \XMM2
 933                 .endif
 934
 935                 vmovdqu  16*2(arg4, %r11), \T1
 936                 vpxor    \T1, \XMM3, \XMM3
 937                 vmovdqu  \XMM3, 16*2(arg3 , %r11)
 938                 .if   \ENC_DEC == DEC
 939                 vmovdqa  \T1, \XMM3
 940                 .endif
 941
 942                 vmovdqu  16*3(arg4, %r11), \T1
 943                 vpxor    \T1, \XMM4, \XMM4
 944                 vmovdqu  \XMM4, 16*3(arg3 , %r11)
 945                 .if   \ENC_DEC == DEC
 946                 vmovdqa  \T1, \XMM4
 947                 .endif
 948
 949                 vmovdqu  16*4(arg4, %r11), \T1
 950                 vpxor    \T1, \XMM5, \XMM5
 951                 vmovdqu  \XMM5, 16*4(arg3 , %r11)
 952                 .if   \ENC_DEC == DEC
 953                 vmovdqa  \T1, \XMM5
 954                 .endif
 955
 956                 vmovdqu  16*5(arg4, %r11), \T1
 957                 vpxor    \T1, \XMM6, \XMM6
 958                 vmovdqu  \XMM6, 16*5(arg3 , %r11)
 959                 .if   \ENC_DEC == DEC
 960                 vmovdqa  \T1, \XMM6
 961                 .endif
 962
 963                 vmovdqu  16*6(arg4, %r11), \T1
 964                 vpxor    \T1, \XMM7, \XMM7
 965                 vmovdqu  \XMM7, 16*6(arg3 , %r11)
 966                 .if   \ENC_DEC == DEC
 967                 vmovdqa  \T1, \XMM7
 968                 .endif
 969
 970                 vmovdqu  16*7(arg4, %r11), \T1
 971                 vpxor    \T1, \XMM8, \XMM8
 972                 vmovdqu  \XMM8, 16*7(arg3 , %r11)
 973                 .if   \ENC_DEC == DEC
 974                 vmovdqa  \T1, \XMM8
 975                 .endif
 976
 977                 add     $128, %r11
 978
 979                 vpshufb  SHUF_MASK(%rip), \XMM1, \XMM1     # perform a 16Byte swap
 980                 vpxor    TMP1(%rsp), \XMM1, \XMM1          # combine GHASHed value with the corresponding ciphertext
 981                 vpshufb  SHUF_MASK(%rip), \XMM2, \XMM2     # perform a 16Byte swap
 982                 vpshufb  SHUF_MASK(%rip), \XMM3, \XMM3     # perform a 16Byte swap
 983                 vpshufb  SHUF_MASK(%rip), \XMM4, \XMM4     # perform a 16Byte swap
 984                 vpshufb  SHUF_MASK(%rip), \XMM5, \XMM5     # perform a 16Byte swap
 985                 vpshufb  SHUF_MASK(%rip), \XMM6, \XMM6     # perform a 16Byte swap
 986                 vpshufb  SHUF_MASK(%rip), \XMM7, \XMM7     # perform a 16Byte swap
 987                 vpshufb  SHUF_MASK(%rip), \XMM8, \XMM8     # perform a 16Byte swap
 988
 989 ###############################################################################
 990
 991 _initial_blocks_done\@:
 992
 993 .endm
 994
 995 # encrypt 8 blocks at a time
 996 # ghash the 8 previously encrypted ciphertext blocks
 997 # arg1, arg3, arg4 are used as pointers only, not modified
 998 # r11 is the data offset value
 999 .macro GHASH_8_ENCRYPT_8_PARALLEL_AVX T1 T2 T3 T4 T5 T6 CTR XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 T7 loop_idx ENC_DEC
1000
1001         vmovdqa \XMM1, \T2
1002         vmovdqa \XMM2, TMP2(%rsp)
1003         vmovdqa \XMM3, TMP3(%rsp)
1004         vmovdqa \XMM4, TMP4(%rsp)
1005         vmovdqa \XMM5, TMP5(%rsp)
1006         vmovdqa \XMM6, TMP6(%rsp)
1007         vmovdqa \XMM7, TMP7(%rsp)
1008         vmovdqa \XMM8, TMP8(%rsp)
1009
1010 .if \loop_idx == in_order
1011                 vpaddd  ONE(%rip), \CTR, \XMM1           # INCR CNT
1012                 vpaddd  ONE(%rip), \XMM1, \XMM2
1013                 vpaddd  ONE(%rip), \XMM2, \XMM3
1014                 vpaddd  ONE(%rip), \XMM3, \XMM4
1015                 vpaddd  ONE(%rip), \XMM4, \XMM5
1016                 vpaddd  ONE(%rip), \XMM5, \XMM6
1017                 vpaddd  ONE(%rip), \XMM6, \XMM7
1018                 vpaddd  ONE(%rip), \XMM7, \XMM8
1019                 vmovdqa \XMM8, \CTR
1020
1021                 vpshufb SHUF_MASK(%rip), \XMM1, \XMM1    # perform a 16Byte swap
1022                 vpshufb SHUF_MASK(%rip), \XMM2, \XMM2    # perform a 16Byte swap
1023                 vpshufb SHUF_MASK(%rip), \XMM3, \XMM3    # perform a 16Byte swap
1024                 vpshufb SHUF_MASK(%rip), \XMM4, \XMM4    # perform a 16Byte swap
1025                 vpshufb SHUF_MASK(%rip), \XMM5, \XMM5    # perform a 16Byte swap
1026                 vpshufb SHUF_MASK(%rip), \XMM6, \XMM6    # perform a 16Byte swap
1027                 vpshufb SHUF_MASK(%rip), \XMM7, \XMM7    # perform a 16Byte swap
1028                 vpshufb SHUF_MASK(%rip), \XMM8, \XMM8    # perform a 16Byte swap
1029 .else
1030                 vpaddd  ONEf(%rip), \CTR, \XMM1           # INCR CNT
1031                 vpaddd  ONEf(%rip), \XMM1, \XMM2
1032                 vpaddd  ONEf(%rip), \XMM2, \XMM3
1033                 vpaddd  ONEf(%rip), \XMM3, \XMM4
1034                 vpaddd  ONEf(%rip), \XMM4, \XMM5
1035                 vpaddd  ONEf(%rip), \XMM5, \XMM6
1036                 vpaddd  ONEf(%rip), \XMM6, \XMM7
1037                 vpaddd  ONEf(%rip), \XMM7, \XMM8
1038                 vmovdqa \XMM8, \CTR
1039 .endif
1040
1041
1042         #######################################################################
1043
1044                 vmovdqu (arg1), \T1
1045                 vpxor   \T1, \XMM1, \XMM1
1046                 vpxor   \T1, \XMM2, \XMM2
1047                 vpxor   \T1, \XMM3, \XMM3
1048                 vpxor   \T1, \XMM4, \XMM4
1049                 vpxor   \T1, \XMM5, \XMM5
1050                 vpxor   \T1, \XMM6, \XMM6
1051                 vpxor   \T1, \XMM7, \XMM7
1052                 vpxor   \T1, \XMM8, \XMM8
1053
1054         #######################################################################
1055
1056
1057
1058
1059
1060                 vmovdqu 16*1(arg1), \T1
1061                 vaesenc \T1, \XMM1, \XMM1
1062                 vaesenc \T1, \XMM2, \XMM2
1063                 vaesenc \T1, \XMM3, \XMM3
1064                 vaesenc \T1, \XMM4, \XMM4
1065                 vaesenc \T1, \XMM5, \XMM5
1066                 vaesenc \T1, \XMM6, \XMM6
1067                 vaesenc \T1, \XMM7, \XMM7
1068                 vaesenc \T1, \XMM8, \XMM8
1069
1070                 vmovdqu 16*2(arg1), \T1
1071                 vaesenc \T1, \XMM1, \XMM1
1072                 vaesenc \T1, \XMM2, \XMM2
1073                 vaesenc \T1, \XMM3, \XMM3
1074                 vaesenc \T1, \XMM4, \XMM4
1075                 vaesenc \T1, \XMM5, \XMM5
1076                 vaesenc \T1, \XMM6, \XMM6
1077                 vaesenc \T1, \XMM7, \XMM7
1078                 vaesenc \T1, \XMM8, \XMM8
1079
1080
1081         #######################################################################
1082
1083         vmovdqu         HashKey_8(arg2), \T5
1084         vpclmulqdq      $0x11, \T5, \T2, \T4             # T4 = a1*b1
1085         vpclmulqdq      $0x00, \T5, \T2, \T7             # T7 = a0*b0
1086
1087         vpshufd         $0b01001110, \T2, \T6
1088         vpxor           \T2, \T6, \T6
1089
1090         vmovdqu         HashKey_8_k(arg2), \T5
1091         vpclmulqdq      $0x00, \T5, \T6, \T6
1092
1093                 vmovdqu 16*3(arg1), \T1
1094                 vaesenc \T1, \XMM1, \XMM1
1095                 vaesenc \T1, \XMM2, \XMM2
1096                 vaesenc \T1, \XMM3, \XMM3
1097                 vaesenc \T1, \XMM4, \XMM4
1098                 vaesenc \T1, \XMM5, \XMM5
1099                 vaesenc \T1, \XMM6, \XMM6
1100                 vaesenc \T1, \XMM7, \XMM7
1101                 vaesenc \T1, \XMM8, \XMM8
1102
1103         vmovdqa         TMP2(%rsp), \T1
1104         vmovdqu         HashKey_7(arg2), \T5
1105         vpclmulqdq      $0x11, \T5, \T1, \T3
1106         vpxor           \T3, \T4, \T4
1107         vpclmulqdq      $0x00, \T5, \T1, \T3
1108         vpxor           \T3, \T7, \T7
1109
1110         vpshufd         $0b01001110, \T1, \T3
1111         vpxor           \T1, \T3, \T3
1112         vmovdqu         HashKey_7_k(arg2), \T5
1113         vpclmulqdq      $0x10, \T5, \T3, \T3
1114         vpxor           \T3, \T6, \T6
1115
1116                 vmovdqu 16*4(arg1), \T1
1117                 vaesenc \T1, \XMM1, \XMM1
1118                 vaesenc \T1, \XMM2, \XMM2
1119                 vaesenc \T1, \XMM3, \XMM3
1120                 vaesenc \T1, \XMM4, \XMM4
1121                 vaesenc \T1, \XMM5, \XMM5
1122                 vaesenc \T1, \XMM6, \XMM6
1123                 vaesenc \T1, \XMM7, \XMM7
1124                 vaesenc \T1, \XMM8, \XMM8
1125
1126         #######################################################################
1127
1128         vmovdqa         TMP3(%rsp), \T1
1129         vmovdqu         HashKey_6(arg2), \T5
1130         vpclmulqdq      $0x11, \T5, \T1, \T3
1131         vpxor           \T3, \T4, \T4
1132         vpclmulqdq      $0x00, \T5, \T1, \T3
1133         vpxor           \T3, \T7, \T7
1134
1135         vpshufd         $0b01001110, \T1, \T3
1136         vpxor           \T1, \T3, \T3
1137         vmovdqu         HashKey_6_k(arg2), \T5
1138         vpclmulqdq      $0x10, \T5, \T3, \T3
1139         vpxor           \T3, \T6, \T6
1140
1141                 vmovdqu 16*5(arg1), \T1
1142                 vaesenc \T1, \XMM1, \XMM1
1143                 vaesenc \T1, \XMM2, \XMM2
1144                 vaesenc \T1, \XMM3, \XMM3
1145                 vaesenc \T1, \XMM4, \XMM4
1146                 vaesenc \T1, \XMM5, \XMM5
1147                 vaesenc \T1, \XMM6, \XMM6
1148                 vaesenc \T1, \XMM7, \XMM7
1149                 vaesenc \T1, \XMM8, \XMM8
1150
1151         vmovdqa         TMP4(%rsp), \T1
1152         vmovdqu         HashKey_5(arg2), \T5
1153         vpclmulqdq      $0x11, \T5, \T1, \T3
1154         vpxor           \T3, \T4, \T4
1155         vpclmulqdq      $0x00, \T5, \T1, \T3
1156         vpxor           \T3, \T7, \T7
1157
1158         vpshufd         $0b01001110, \T1, \T3
1159         vpxor           \T1, \T3, \T3
1160         vmovdqu         HashKey_5_k(arg2), \T5
1161         vpclmulqdq      $0x10, \T5, \T3, \T3
1162         vpxor           \T3, \T6, \T6
1163
1164                 vmovdqu 16*6(arg1), \T1
1165                 vaesenc \T1, \XMM1, \XMM1
1166                 vaesenc \T1, \XMM2, \XMM2
1167                 vaesenc \T1, \XMM3, \XMM3
1168                 vaesenc \T1, \XMM4, \XMM4
1169                 vaesenc \T1, \XMM5, \XMM5
1170                 vaesenc \T1, \XMM6, \XMM6
1171                 vaesenc \T1, \XMM7, \XMM7
1172                 vaesenc \T1, \XMM8, \XMM8
1173
1174
1175         vmovdqa         TMP5(%rsp), \T1
1176         vmovdqu         HashKey_4(arg2), \T5
1177         vpclmulqdq      $0x11, \T5, \T1, \T3
1178         vpxor           \T3, \T4, \T4
1179         vpclmulqdq      $0x00, \T5, \T1, \T3
1180         vpxor           \T3, \T7, \T7
1181
1182         vpshufd         $0b01001110, \T1, \T3
1183         vpxor           \T1, \T3, \T3
1184         vmovdqu         HashKey_4_k(arg2), \T5
1185         vpclmulqdq      $0x10, \T5, \T3, \T3
1186         vpxor           \T3, \T6, \T6
1187
1188                 vmovdqu 16*7(arg1), \T1
1189                 vaesenc \T1, \XMM1, \XMM1
1190                 vaesenc \T1, \XMM2, \XMM2
1191                 vaesenc \T1, \XMM3, \XMM3
1192                 vaesenc \T1, \XMM4, \XMM4
1193                 vaesenc \T1, \XMM5, \XMM5
1194                 vaesenc \T1, \XMM6, \XMM6
1195                 vaesenc \T1, \XMM7, \XMM7
1196                 vaesenc \T1, \XMM8, \XMM8
1197
1198         vmovdqa         TMP6(%rsp), \T1
1199         vmovdqu         HashKey_3(arg2), \T5
1200         vpclmulqdq      $0x11, \T5, \T1, \T3
1201         vpxor           \T3, \T4, \T4
1202         vpclmulqdq      $0x00, \T5, \T1, \T3
1203         vpxor           \T3, \T7, \T7
1204
1205         vpshufd         $0b01001110, \T1, \T3
1206         vpxor           \T1, \T3, \T3
1207         vmovdqu         HashKey_3_k(arg2), \T5
1208         vpclmulqdq      $0x10, \T5, \T3, \T3
1209         vpxor           \T3, \T6, \T6
1210
1211
1212                 vmovdqu 16*8(arg1), \T1
1213                 vaesenc \T1, \XMM1, \XMM1
1214                 vaesenc \T1, \XMM2, \XMM2
1215                 vaesenc \T1, \XMM3, \XMM3
1216                 vaesenc \T1, \XMM4, \XMM4
1217                 vaesenc \T1, \XMM5, \XMM5
1218                 vaesenc \T1, \XMM6, \XMM6
1219                 vaesenc \T1, \XMM7, \XMM7
1220                 vaesenc \T1, \XMM8, \XMM8
1221
1222         vmovdqa         TMP7(%rsp), \T1
1223         vmovdqu         HashKey_2(arg2), \T5
1224         vpclmulqdq      $0x11, \T5, \T1, \T3
1225         vpxor           \T3, \T4, \T4
1226         vpclmulqdq      $0x00, \T5, \T1, \T3
1227         vpxor           \T3, \T7, \T7
1228
1229         vpshufd         $0b01001110, \T1, \T3
1230         vpxor           \T1, \T3, \T3
1231         vmovdqu         HashKey_2_k(arg2), \T5
1232         vpclmulqdq      $0x10, \T5, \T3, \T3
1233         vpxor           \T3, \T6, \T6
1234
1235         #######################################################################
1236
1237                 vmovdqu 16*9(arg1), \T5
1238                 vaesenc \T5, \XMM1, \XMM1
1239                 vaesenc \T5, \XMM2, \XMM2
1240                 vaesenc \T5, \XMM3, \XMM3
1241                 vaesenc \T5, \XMM4, \XMM4
1242                 vaesenc \T5, \XMM5, \XMM5
1243                 vaesenc \T5, \XMM6, \XMM6
1244                 vaesenc \T5, \XMM7, \XMM7
1245                 vaesenc \T5, \XMM8, \XMM8
1246
1247         vmovdqa         TMP8(%rsp), \T1
1248         vmovdqu         HashKey(arg2), \T5
1249         vpclmulqdq      $0x11, \T5, \T1, \T3
1250         vpxor           \T3, \T4, \T4
1251         vpclmulqdq      $0x00, \T5, \T1, \T3
1252         vpxor           \T3, \T7, \T7
1253
1254         vpshufd         $0b01001110, \T1, \T3
1255         vpxor           \T1, \T3, \T3
1256         vmovdqu         HashKey_k(arg2), \T5
1257         vpclmulqdq      $0x10, \T5, \T3, \T3
1258         vpxor           \T3, \T6, \T6
1259
1260         vpxor           \T4, \T6, \T6
1261         vpxor           \T7, \T6, \T6
1262
1263                 vmovdqu 16*10(arg1), \T5
1264
1265         i = 0
1266         j = 1
1267         setreg
1268 .rep 8
1269                 vpxor   16*i(arg4, %r11), \T5, \T2
1270                 .if \ENC_DEC == ENC
1271                 vaesenclast     \T2, reg_j, reg_j
1272                 .else
1273                 vaesenclast     \T2, reg_j, \T3
1274                 vmovdqu 16*i(arg4, %r11), reg_j
1275                 vmovdqu \T3, 16*i(arg3, %r11)
1276                 .endif
1277         i = (i+1)
1278         j = (j+1)
1279         setreg
1280 .endr
1281         #######################################################################
1282
1283
1284         vpslldq $8, \T6, \T3                            # shift-L T3 2 DWs
1285         vpsrldq $8, \T6, \T6                            # shift-R T2 2 DWs
1286         vpxor   \T3, \T7, \T7
1287         vpxor   \T4, \T6, \T6                           # accumulate the results in T6:T7
1288
1289
1290
1291         #######################################################################
1292         #first phase of the reduction
1293         #######################################################################
1294         vpslld  $31, \T7, \T2                           # packed right shifting << 31
1295         vpslld  $30, \T7, \T3                           # packed right shifting shift << 30
1296         vpslld  $25, \T7, \T4                           # packed right shifting shift << 25
1297
1298         vpxor   \T3, \T2, \T2                           # xor the shifted versions
1299         vpxor   \T4, \T2, \T2
1300
1301         vpsrldq $4, \T2, \T1                            # shift-R T1 1 DW
1302
1303         vpslldq $12, \T2, \T2                           # shift-L T2 3 DWs
1304         vpxor   \T2, \T7, \T7                           # first phase of the reduction complete
1305         #######################################################################
1306                 .if \ENC_DEC == ENC
1307                 vmovdqu  \XMM1, 16*0(arg3,%r11)         # Write to the Ciphertext buffer
1308                 vmovdqu  \XMM2, 16*1(arg3,%r11)         # Write to the Ciphertext buffer
1309                 vmovdqu  \XMM3, 16*2(arg3,%r11)         # Write to the Ciphertext buffer
1310                 vmovdqu  \XMM4, 16*3(arg3,%r11)         # Write to the Ciphertext buffer
1311                 vmovdqu  \XMM5, 16*4(arg3,%r11)         # Write to the Ciphertext buffer
1312                 vmovdqu  \XMM6, 16*5(arg3,%r11)         # Write to the Ciphertext buffer
1313                 vmovdqu  \XMM7, 16*6(arg3,%r11)         # Write to the Ciphertext buffer
1314                 vmovdqu  \XMM8, 16*7(arg3,%r11)         # Write to the Ciphertext buffer
1315                 .endif
1316
1317         #######################################################################
1318         #second phase of the reduction
1319         vpsrld  $1, \T7, \T2                            # packed left shifting >> 1
1320         vpsrld  $2, \T7, \T3                            # packed left shifting >> 2
1321         vpsrld  $7, \T7, \T4                            # packed left shifting >> 7
1322         vpxor   \T3, \T2, \T2                           # xor the shifted versions
1323         vpxor   \T4, \T2, \T2
1324
1325         vpxor   \T1, \T2, \T2
1326         vpxor   \T2, \T7, \T7
1327         vpxor   \T7, \T6, \T6                           # the result is in T6
1328         #######################################################################
1329
1330                 vpshufb SHUF_MASK(%rip), \XMM1, \XMM1   # perform a 16Byte swap
1331                 vpshufb SHUF_MASK(%rip), \XMM2, \XMM2   # perform a 16Byte swap
1332                 vpshufb SHUF_MASK(%rip), \XMM3, \XMM3   # perform a 16Byte swap
1333                 vpshufb SHUF_MASK(%rip), \XMM4, \XMM4   # perform a 16Byte swap
1334                 vpshufb SHUF_MASK(%rip), \XMM5, \XMM5   # perform a 16Byte swap
1335                 vpshufb SHUF_MASK(%rip), \XMM6, \XMM6   # perform a 16Byte swap
1336                 vpshufb SHUF_MASK(%rip), \XMM7, \XMM7   # perform a 16Byte swap
1337                 vpshufb SHUF_MASK(%rip), \XMM8, \XMM8   # perform a 16Byte swap
1338
1339
1340         vpxor   \T6, \XMM1, \XMM1
1341
1342
1343
1344 .endm
1345
1346
1347 # GHASH the last 4 ciphertext blocks.
1348 .macro  GHASH_LAST_8_AVX T1 T2 T3 T4 T5 T6 T7 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8
1349
1350         ## Karatsuba Method
1351
1352
1353         vpshufd         $0b01001110, \XMM1, \T2
1354         vpxor           \XMM1, \T2, \T2
1355         vmovdqu         HashKey_8(arg2), \T5
1356         vpclmulqdq      $0x11, \T5, \XMM1, \T6
1357         vpclmulqdq      $0x00, \T5, \XMM1, \T7
1358
1359         vmovdqu         HashKey_8_k(arg2), \T3
1360         vpclmulqdq      $0x00, \T3, \T2, \XMM1
1361
1362         ######################
1363
1364         vpshufd         $0b01001110, \XMM2, \T2
1365         vpxor           \XMM2, \T2, \T2
1366         vmovdqu         HashKey_7(arg2), \T5
1367         vpclmulqdq      $0x11, \T5, \XMM2, \T4
1368         vpxor           \T4, \T6, \T6
1369
1370         vpclmulqdq      $0x00, \T5, \XMM2, \T4
1371         vpxor           \T4, \T7, \T7
1372
1373         vmovdqu         HashKey_7_k(arg2), \T3
1374         vpclmulqdq      $0x00, \T3, \T2, \T2
1375         vpxor           \T2, \XMM1, \XMM1
1376
1377         ######################
1378
1379         vpshufd         $0b01001110, \XMM3, \T2
1380         vpxor           \XMM3, \T2, \T2
1381         vmovdqu         HashKey_6(arg2), \T5
1382         vpclmulqdq      $0x11, \T5, \XMM3, \T4
1383         vpxor           \T4, \T6, \T6
1384
1385         vpclmulqdq      $0x00, \T5, \XMM3, \T4
1386         vpxor           \T4, \T7, \T7
1387
1388         vmovdqu         HashKey_6_k(arg2), \T3
1389         vpclmulqdq      $0x00, \T3, \T2, \T2
1390         vpxor           \T2, \XMM1, \XMM1
1391
1392         ######################
1393
1394         vpshufd         $0b01001110, \XMM4, \T2
1395         vpxor           \XMM4, \T2, \T2
1396         vmovdqu         HashKey_5(arg2), \T5
1397         vpclmulqdq      $0x11, \T5, \XMM4, \T4
1398         vpxor           \T4, \T6, \T6
1399
1400         vpclmulqdq      $0x00, \T5, \XMM4, \T4
1401         vpxor           \T4, \T7, \T7
1402
1403         vmovdqu         HashKey_5_k(arg2), \T3
1404         vpclmulqdq      $0x00, \T3, \T2, \T2
1405         vpxor           \T2, \XMM1, \XMM1
1406
1407         ######################
1408
1409         vpshufd         $0b01001110, \XMM5, \T2
1410         vpxor           \XMM5, \T2, \T2
1411         vmovdqu         HashKey_4(arg2), \T5
1412         vpclmulqdq      $0x11, \T5, \XMM5, \T4
1413         vpxor           \T4, \T6, \T6
1414
1415         vpclmulqdq      $0x00, \T5, \XMM5, \T4
1416         vpxor           \T4, \T7, \T7
1417
1418         vmovdqu         HashKey_4_k(arg2), \T3
1419         vpclmulqdq      $0x00, \T3, \T2, \T2
1420         vpxor           \T2, \XMM1, \XMM1
1421
1422         ######################
1423
1424         vpshufd         $0b01001110, \XMM6, \T2
1425         vpxor           \XMM6, \T2, \T2
1426         vmovdqu         HashKey_3(arg2), \T5
1427         vpclmulqdq      $0x11, \T5, \XMM6, \T4
1428         vpxor           \T4, \T6, \T6
1429
1430         vpclmulqdq      $0x00, \T5, \XMM6, \T4
1431         vpxor           \T4, \T7, \T7
1432
1433         vmovdqu         HashKey_3_k(arg2), \T3
1434         vpclmulqdq      $0x00, \T3, \T2, \T2
1435         vpxor           \T2, \XMM1, \XMM1
1436
1437         ######################
1438
1439         vpshufd         $0b01001110, \XMM7, \T2
1440         vpxor           \XMM7, \T2, \T2
1441         vmovdqu         HashKey_2(arg2), \T5
1442         vpclmulqdq      $0x11, \T5, \XMM7, \T4
1443         vpxor           \T4, \T6, \T6
1444
1445         vpclmulqdq      $0x00, \T5, \XMM7, \T4
1446         vpxor           \T4, \T7, \T7
1447
1448         vmovdqu         HashKey_2_k(arg2), \T3
1449         vpclmulqdq      $0x00, \T3, \T2, \T2
1450         vpxor           \T2, \XMM1, \XMM1
1451
1452         ######################
1453
1454         vpshufd         $0b01001110, \XMM8, \T2
1455         vpxor           \XMM8, \T2, \T2
1456         vmovdqu         HashKey(arg2), \T5
1457         vpclmulqdq      $0x11, \T5, \XMM8, \T4
1458         vpxor           \T4, \T6, \T6
1459
1460         vpclmulqdq      $0x00, \T5, \XMM8, \T4
1461         vpxor           \T4, \T7, \T7
1462
1463         vmovdqu         HashKey_k(arg2), \T3
1464         vpclmulqdq      $0x00, \T3, \T2, \T2
1465
1466         vpxor           \T2, \XMM1, \XMM1
1467         vpxor           \T6, \XMM1, \XMM1
1468         vpxor           \T7, \XMM1, \T2
1469
1470
1471
1472
1473         vpslldq $8, \T2, \T4
1474         vpsrldq $8, \T2, \T2
1475
1476         vpxor   \T4, \T7, \T7
1477         vpxor   \T2, \T6, \T6   # <T6:T7> holds the result of
1478                                 # the accumulated carry-less multiplications
1479
1480         #######################################################################
1481         #first phase of the reduction
1482         vpslld  $31, \T7, \T2   # packed right shifting << 31
1483         vpslld  $30, \T7, \T3   # packed right shifting shift << 30
1484         vpslld  $25, \T7, \T4   # packed right shifting shift << 25
1485
1486         vpxor   \T3, \T2, \T2   # xor the shifted versions
1487         vpxor   \T4, \T2, \T2
1488
1489         vpsrldq $4, \T2, \T1    # shift-R T1 1 DW
1490
1491         vpslldq $12, \T2, \T2   # shift-L T2 3 DWs
1492         vpxor   \T2, \T7, \T7   # first phase of the reduction complete
1493         #######################################################################
1494
1495
1496         #second phase of the reduction
1497         vpsrld  $1, \T7, \T2    # packed left shifting >> 1
1498         vpsrld  $2, \T7, \T3    # packed left shifting >> 2
1499         vpsrld  $7, \T7, \T4    # packed left shifting >> 7
1500         vpxor   \T3, \T2, \T2   # xor the shifted versions
1501         vpxor   \T4, \T2, \T2
1502
1503         vpxor   \T1, \T2, \T2
1504         vpxor   \T2, \T7, \T7
1505         vpxor   \T7, \T6, \T6   # the result is in T6
1506
1507 .endm
1508
1509 #############################################################
1510 #void   aesni_gcm_precomp_avx_gen2
1511 #        (gcm_data     *my_ctx_data,
1512 #         gcm_context_data *data,
1513 #        u8     *hash_subkey)# /* H, the Hash sub key input. Data starts on a 16-byte boundary. */
1514 #############################################################
1515 ENTRY(aesni_gcm_precomp_avx_gen2)
1516         FUNC_SAVE
1517
1518         vmovdqu  (arg3), %xmm6              # xmm6 = HashKey
1519
1520         vpshufb  SHUF_MASK(%rip), %xmm6, %xmm6
1521         ###############  PRECOMPUTATION of HashKey<<1 mod poly from the HashKey
1522         vmovdqa  %xmm6, %xmm2
1523         vpsllq   $1, %xmm6, %xmm6
1524         vpsrlq   $63, %xmm2, %xmm2
1525         vmovdqa  %xmm2, %xmm1
1526         vpslldq  $8, %xmm2, %xmm2
1527         vpsrldq  $8, %xmm1, %xmm1
1528         vpor     %xmm2, %xmm6, %xmm6
1529         #reduction
1530         vpshufd  $0b00100100, %xmm1, %xmm2
1531         vpcmpeqd TWOONE(%rip), %xmm2, %xmm2
1532         vpand    POLY(%rip), %xmm2, %xmm2
1533         vpxor    %xmm2, %xmm6, %xmm6        # xmm6 holds the HashKey<<1 mod poly
1534         #######################################################################
1535         vmovdqu  %xmm6, HashKey(arg2)       # store HashKey<<1 mod poly
1536
1537
1538         PRECOMPUTE_AVX  %xmm6, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5
1539
1540         FUNC_RESTORE
1541         ret
1542 ENDPROC(aesni_gcm_precomp_avx_gen2)
1543
1544 ###############################################################################
1545 #void   aesni_gcm_enc_avx_gen2(
1546 #        gcm_data        *my_ctx_data,     /* aligned to 16 Bytes */
1547 #        gcm_context_data *data,
1548 #        u8      *out, /* Ciphertext output. Encrypt in-place is allowed.  */
1549 #        const   u8 *in, /* Plaintext input */
1550 #        u64     plaintext_len, /* Length of data in Bytes for encryption. */
1551 #        u8      *iv, /* Pre-counter block j0: 4 byte salt
1552 #                       (from Security Association) concatenated with 8 byte
1553 #                       Initialisation Vector (from IPSec ESP Payload)
1554 #                       concatenated with 0x00000001. 16-byte aligned pointer. */
1555 #        const   u8 *aad, /* Additional Authentication Data (AAD)*/
1556 #        u64     aad_len, /* Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 Bytes */
1557 #        u8      *auth_tag, /* Authenticated Tag output. */
1558 #        u64     auth_tag_len)# /* Authenticated Tag Length in bytes.
1559 #                               Valid values are 16 (most likely), 12 or 8. */
1560 ###############################################################################
1561 ENTRY(aesni_gcm_enc_avx_gen2)
1562         FUNC_SAVE
1563         GCM_ENC_DEC INITIAL_BLOCKS_AVX GHASH_8_ENCRYPT_8_PARALLEL_AVX GHASH_LAST_8_AVX GHASH_MUL_AVX ENC
1564         FUNC_RESTORE
1565         ret
1566 ENDPROC(aesni_gcm_enc_avx_gen2)
1567
1568 ###############################################################################
1569 #void   aesni_gcm_dec_avx_gen2(
1570 #        gcm_data        *my_ctx_data,     /* aligned to 16 Bytes */
1571 #        gcm_context_data *data,
1572 #        u8      *out, /* Plaintext output. Decrypt in-place is allowed.  */
1573 #        const   u8 *in, /* Ciphertext input */
1574 #        u64     plaintext_len, /* Length of data in Bytes for encryption. */
1575 #        u8      *iv, /* Pre-counter block j0: 4 byte salt
1576 #                       (from Security Association) concatenated with 8 byte
1577 #                       Initialisation Vector (from IPSec ESP Payload)
1578 #                       concatenated with 0x00000001. 16-byte aligned pointer. */
1579 #        const   u8 *aad, /* Additional Authentication Data (AAD)*/
1580 #        u64     aad_len, /* Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 Bytes */
1581 #        u8      *auth_tag, /* Authenticated Tag output. */
1582 #        u64     auth_tag_len)# /* Authenticated Tag Length in bytes.
1583 #                               Valid values are 16 (most likely), 12 or 8. */
1584 ###############################################################################
1585 ENTRY(aesni_gcm_dec_avx_gen2)
1586         FUNC_SAVE
1587         GCM_ENC_DEC INITIAL_BLOCKS_AVX GHASH_8_ENCRYPT_8_PARALLEL_AVX GHASH_LAST_8_AVX GHASH_MUL_AVX DEC
1588         FUNC_RESTORE
1589         ret
1590 ENDPROC(aesni_gcm_dec_avx_gen2)
1591 #endif /* CONFIG_AS_AVX */
1592
1593 #ifdef CONFIG_AS_AVX2
1594 ###############################################################################
1595 # GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
1596 # Input: A and B (128-bits each, bit-reflected)
1597 # Output: C = A*B*x mod poly, (i.e. >>1 )
1598 # To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
1599 # GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
1600 ###############################################################################
1601 .macro  GHASH_MUL_AVX2 GH HK T1 T2 T3 T4 T5
1602
1603         vpclmulqdq      $0x11,\HK,\GH,\T1      # T1 = a1*b1
1604         vpclmulqdq      $0x00,\HK,\GH,\T2      # T2 = a0*b0
1605         vpclmulqdq      $0x01,\HK,\GH,\T3      # T3 = a1*b0
1606         vpclmulqdq      $0x10,\HK,\GH,\GH      # GH = a0*b1
1607         vpxor           \T3, \GH, \GH
1608
1609
1610         vpsrldq         $8 , \GH, \T3          # shift-R GH 2 DWs
1611         vpslldq         $8 , \GH, \GH          # shift-L GH 2 DWs
1612
1613         vpxor           \T3, \T1, \T1
1614         vpxor           \T2, \GH, \GH
1615
1616         #######################################################################
1617         #first phase of the reduction
1618         vmovdqa         POLY2(%rip), \T3
1619
1620         vpclmulqdq      $0x01, \GH, \T3, \T2
1621         vpslldq         $8, \T2, \T2           # shift-L T2 2 DWs
1622
1623         vpxor           \T2, \GH, \GH          # first phase of the reduction complete
1624         #######################################################################
1625         #second phase of the reduction
1626         vpclmulqdq      $0x00, \GH, \T3, \T2
1627         vpsrldq         $4, \T2, \T2           # shift-R T2 1 DW (Shift-R only 1-DW to obtain 2-DWs shift-R)
1628
1629         vpclmulqdq      $0x10, \GH, \T3, \GH
1630         vpslldq         $4, \GH, \GH           # shift-L GH 1 DW (Shift-L 1-DW to obtain result with no shifts)
1631
1632         vpxor           \T2, \GH, \GH          # second phase of the reduction complete
1633         #######################################################################
1634         vpxor           \T1, \GH, \GH          # the result is in GH
1635
1636
1637 .endm
1638
1639 .macro PRECOMPUTE_AVX2 HK T1 T2 T3 T4 T5 T6
1640
1641         # Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
1642         vmovdqa  \HK, \T5
1643         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^2<<1 mod poly
1644         vmovdqu  \T5, HashKey_2(arg2)                       #  [HashKey_2] = HashKey^2<<1 mod poly
1645
1646         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^3<<1 mod poly
1647         vmovdqu  \T5, HashKey_3(arg2)
1648
1649         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^4<<1 mod poly
1650         vmovdqu  \T5, HashKey_4(arg2)
1651
1652         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^5<<1 mod poly
1653         vmovdqu  \T5, HashKey_5(arg2)
1654
1655         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^6<<1 mod poly
1656         vmovdqu  \T5, HashKey_6(arg2)
1657
1658         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^7<<1 mod poly
1659         vmovdqu  \T5, HashKey_7(arg2)
1660
1661         GHASH_MUL_AVX2 \T5, \HK, \T1, \T3, \T4, \T6, \T2    #  T5 = HashKey^8<<1 mod poly
1662         vmovdqu  \T5, HashKey_8(arg2)
1663
1664 .endm
1665
1666
1667 ## if a = number of total plaintext bytes
1668 ## b = floor(a/16)
1669 ## num_initial_blocks = b mod 4#
1670 ## encrypt the initial num_initial_blocks blocks and apply ghash on the ciphertext
1671 ## r10, r11, r12, rax are clobbered
1672 ## arg1, arg3, arg4, r14 are used as a pointer only, not modified
1673
1674 .macro INITIAL_BLOCKS_AVX2 num_initial_blocks T1 T2 T3 T4 T5 CTR XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 T6 T_key ENC_DEC VER
1675         i = (8-\num_initial_blocks)
1676         j = 0
1677         setreg
1678
1679         mov     arg7, %r10                       # r10 = AAD
1680         mov     arg8, %r12                       # r12 = aadLen
1681
1682
1683         mov     %r12, %r11
1684
1685         vpxor   reg_j, reg_j, reg_j
1686         vpxor   reg_i, reg_i, reg_i
1687
1688         cmp     $16, %r11
1689         jl      _get_AAD_rest8\@
1690 _get_AAD_blocks\@:
1691         vmovdqu (%r10), reg_i
1692         vpshufb SHUF_MASK(%rip), reg_i, reg_i
1693         vpxor   reg_i, reg_j, reg_j
1694         GHASH_MUL_AVX2      reg_j, \T2, \T1, \T3, \T4, \T5, \T6
1695         add     $16, %r10
1696         sub     $16, %r12
1697         sub     $16, %r11
1698         cmp     $16, %r11
1699         jge     _get_AAD_blocks\@
1700         vmovdqu reg_j, reg_i
1701         cmp     $0, %r11
1702         je      _get_AAD_done\@
1703
1704         vpxor   reg_i, reg_i, reg_i
1705
1706         /* read the last <16B of AAD. since we have at least 4B of
1707         data right after the AAD (the ICV, and maybe some CT), we can
1708         read 4B/8B blocks safely, and then get rid of the extra stuff */
1709 _get_AAD_rest8\@:
1710         cmp     $4, %r11
1711         jle     _get_AAD_rest4\@
1712         movq    (%r10), \T1
1713         add     $8, %r10
1714         sub     $8, %r11
1715         vpslldq $8, \T1, \T1
1716         vpsrldq $8, reg_i, reg_i
1717         vpxor   \T1, reg_i, reg_i
1718         jmp     _get_AAD_rest8\@
1719 _get_AAD_rest4\@:
1720         cmp     $0, %r11
1721         jle     _get_AAD_rest0\@
1722         mov     (%r10), %eax
1723         movq    %rax, \T1
1724         add     $4, %r10
1725         sub     $4, %r11
1726         vpslldq $12, \T1, \T1
1727         vpsrldq $4, reg_i, reg_i
1728         vpxor   \T1, reg_i, reg_i
1729 _get_AAD_rest0\@:
1730         /* finalize: shift out the extra bytes we read, and align
1731         left. since pslldq can only shift by an immediate, we use
1732         vpshufb and an array of shuffle masks */
1733         movq    %r12, %r11
1734         salq    $4, %r11
1735         movdqu  aad_shift_arr(%r11), \T1
1736         vpshufb \T1, reg_i, reg_i
1737 _get_AAD_rest_final\@:
1738         vpshufb SHUF_MASK(%rip), reg_i, reg_i
1739         vpxor   reg_j, reg_i, reg_i
1740         GHASH_MUL_AVX2      reg_i, \T2, \T1, \T3, \T4, \T5, \T6
1741
1742 _get_AAD_done\@:
1743         # initialize the data pointer offset as zero
1744         xor     %r11d, %r11d
1745
1746         # start AES for num_initial_blocks blocks
1747         mov     arg6, %rax                     # rax = *Y0
1748         vmovdqu (%rax), \CTR                   # CTR = Y0
1749         vpshufb SHUF_MASK(%rip), \CTR, \CTR
1750
1751
1752         i = (9-\num_initial_blocks)
1753         setreg
1754 .rep \num_initial_blocks
1755                 vpaddd  ONE(%rip), \CTR, \CTR   # INCR Y0
1756                 vmovdqa \CTR, reg_i
1757                 vpshufb SHUF_MASK(%rip), reg_i, reg_i     # perform a 16Byte swap
1758         i = (i+1)
1759         setreg
1760 .endr
1761
1762         vmovdqa  (arg1), \T_key
1763         i = (9-\num_initial_blocks)
1764         setreg
1765 .rep \num_initial_blocks
1766                 vpxor   \T_key, reg_i, reg_i
1767         i = (i+1)
1768         setreg
1769 .endr
1770
1771         j = 1
1772         setreg
1773 .rep 9
1774         vmovdqa  16*j(arg1), \T_key
1775         i = (9-\num_initial_blocks)
1776         setreg
1777 .rep \num_initial_blocks
1778         vaesenc \T_key, reg_i, reg_i
1779         i = (i+1)
1780         setreg
1781 .endr
1782
1783         j = (j+1)
1784         setreg
1785 .endr
1786
1787
1788         vmovdqa  16*10(arg1), \T_key
1789         i = (9-\num_initial_blocks)
1790         setreg
1791 .rep \num_initial_blocks
1792         vaesenclast      \T_key, reg_i, reg_i
1793         i = (i+1)
1794         setreg
1795 .endr
1796
1797         i = (9-\num_initial_blocks)
1798         setreg
1799 .rep \num_initial_blocks
1800                 vmovdqu (arg4, %r11), \T1
1801                 vpxor   \T1, reg_i, reg_i
1802                 vmovdqu reg_i, (arg3 , %r11)           # write back ciphertext for
1803                                                        # num_initial_blocks blocks
1804                 add     $16, %r11
1805 .if  \ENC_DEC == DEC
1806                 vmovdqa \T1, reg_i
1807 .endif
1808                 vpshufb SHUF_MASK(%rip), reg_i, reg_i  # prepare ciphertext for GHASH computations
1809         i = (i+1)
1810         setreg
1811 .endr
1812
1813
1814         i = (8-\num_initial_blocks)
1815         j = (9-\num_initial_blocks)
1816         setreg
1817
1818 .rep \num_initial_blocks
1819         vpxor    reg_i, reg_j, reg_j
1820         GHASH_MUL_AVX2       reg_j, \T2, \T1, \T3, \T4, \T5, \T6  # apply GHASH on num_initial_blocks blocks
1821         i = (i+1)
1822         j = (j+1)
1823         setreg
1824 .endr
1825         # XMM8 has the combined result here
1826
1827         vmovdqa  \XMM8, TMP1(%rsp)
1828         vmovdqa  \XMM8, \T3
1829
1830         cmp     $128, %r13
1831         jl      _initial_blocks_done\@                  # no need for precomputed constants
1832
1833 ###############################################################################
1834 # Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
1835                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1836                 vmovdqa  \CTR, \XMM1
1837                 vpshufb  SHUF_MASK(%rip), \XMM1, \XMM1  # perform a 16Byte swap
1838
1839                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1840                 vmovdqa  \CTR, \XMM2
1841                 vpshufb  SHUF_MASK(%rip), \XMM2, \XMM2  # perform a 16Byte swap
1842
1843                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1844                 vmovdqa  \CTR, \XMM3
1845                 vpshufb  SHUF_MASK(%rip), \XMM3, \XMM3  # perform a 16Byte swap
1846
1847                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1848                 vmovdqa  \CTR, \XMM4
1849                 vpshufb  SHUF_MASK(%rip), \XMM4, \XMM4  # perform a 16Byte swap
1850
1851                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1852                 vmovdqa  \CTR, \XMM5
1853                 vpshufb  SHUF_MASK(%rip), \XMM5, \XMM5  # perform a 16Byte swap
1854
1855                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1856                 vmovdqa  \CTR, \XMM6
1857                 vpshufb  SHUF_MASK(%rip), \XMM6, \XMM6  # perform a 16Byte swap
1858
1859                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1860                 vmovdqa  \CTR, \XMM7
1861                 vpshufb  SHUF_MASK(%rip), \XMM7, \XMM7  # perform a 16Byte swap
1862
1863                 vpaddd   ONE(%rip), \CTR, \CTR          # INCR Y0
1864                 vmovdqa  \CTR, \XMM8
1865                 vpshufb  SHUF_MASK(%rip), \XMM8, \XMM8  # perform a 16Byte swap
1866
1867                 vmovdqa  (arg1), \T_key
1868                 vpxor    \T_key, \XMM1, \XMM1
1869                 vpxor    \T_key, \XMM2, \XMM2
1870                 vpxor    \T_key, \XMM3, \XMM3
1871                 vpxor    \T_key, \XMM4, \XMM4
1872                 vpxor    \T_key, \XMM5, \XMM5
1873                 vpxor    \T_key, \XMM6, \XMM6
1874                 vpxor    \T_key, \XMM7, \XMM7
1875                 vpxor    \T_key, \XMM8, \XMM8
1876
1877                 i = 1
1878                 setreg
1879 .rep    9       # do 9 rounds
1880                 vmovdqa  16*i(arg1), \T_key
1881                 vaesenc  \T_key, \XMM1, \XMM1
1882                 vaesenc  \T_key, \XMM2, \XMM2
1883                 vaesenc  \T_key, \XMM3, \XMM3
1884                 vaesenc  \T_key, \XMM4, \XMM4
1885                 vaesenc  \T_key, \XMM5, \XMM5
1886                 vaesenc  \T_key, \XMM6, \XMM6
1887                 vaesenc  \T_key, \XMM7, \XMM7
1888                 vaesenc  \T_key, \XMM8, \XMM8
1889                 i = (i+1)
1890                 setreg
1891 .endr
1892
1893
1894                 vmovdqa  16*i(arg1), \T_key
1895                 vaesenclast  \T_key, \XMM1, \XMM1
1896                 vaesenclast  \T_key, \XMM2, \XMM2
1897                 vaesenclast  \T_key, \XMM3, \XMM3
1898                 vaesenclast  \T_key, \XMM4, \XMM4
1899                 vaesenclast  \T_key, \XMM5, \XMM5
1900                 vaesenclast  \T_key, \XMM6, \XMM6
1901                 vaesenclast  \T_key, \XMM7, \XMM7
1902                 vaesenclast  \T_key, \XMM8, \XMM8
1903
1904                 vmovdqu  (arg4, %r11), \T1
1905                 vpxor    \T1, \XMM1, \XMM1
1906                 vmovdqu  \XMM1, (arg3 , %r11)
1907                 .if   \ENC_DEC == DEC
1908                 vmovdqa  \T1, \XMM1
1909                 .endif
1910
1911                 vmovdqu  16*1(arg4, %r11), \T1
1912                 vpxor    \T1, \XMM2, \XMM2
1913                 vmovdqu  \XMM2, 16*1(arg3 , %r11)
1914                 .if   \ENC_DEC == DEC
1915                 vmovdqa  \T1, \XMM2
1916                 .endif
1917
1918                 vmovdqu  16*2(arg4, %r11), \T1
1919                 vpxor    \T1, \XMM3, \XMM3
1920                 vmovdqu  \XMM3, 16*2(arg3 , %r11)
1921                 .if   \ENC_DEC == DEC
1922                 vmovdqa  \T1, \XMM3
1923                 .endif
1924
1925                 vmovdqu  16*3(arg4, %r11), \T1
1926                 vpxor    \T1, \XMM4, \XMM4
1927                 vmovdqu  \XMM4, 16*3(arg3 , %r11)
1928                 .if   \ENC_DEC == DEC
1929                 vmovdqa  \T1, \XMM4
1930                 .endif
1931
1932                 vmovdqu  16*4(arg4, %r11), \T1
1933                 vpxor    \T1, \XMM5, \XMM5
1934                 vmovdqu  \XMM5, 16*4(arg3 , %r11)
1935                 .if   \ENC_DEC == DEC
1936                 vmovdqa  \T1, \XMM5
1937                 .endif
1938
1939                 vmovdqu  16*5(arg4, %r11), \T1
1940                 vpxor    \T1, \XMM6, \XMM6
1941                 vmovdqu  \XMM6, 16*5(arg3 , %r11)
1942                 .if   \ENC_DEC == DEC
1943                 vmovdqa  \T1, \XMM6
1944                 .endif
1945
1946                 vmovdqu  16*6(arg4, %r11), \T1
1947                 vpxor    \T1, \XMM7, \XMM7
1948                 vmovdqu  \XMM7, 16*6(arg3 , %r11)
1949                 .if   \ENC_DEC == DEC
1950                 vmovdqa  \T1, \XMM7
1951                 .endif
1952
1953                 vmovdqu  16*7(arg4, %r11), \T1
1954                 vpxor    \T1, \XMM8, \XMM8
1955                 vmovdqu  \XMM8, 16*7(arg3 , %r11)
1956                 .if   \ENC_DEC == DEC
1957                 vmovdqa  \T1, \XMM8
1958                 .endif
1959
1960                 add     $128, %r11
1961
1962                 vpshufb  SHUF_MASK(%rip), \XMM1, \XMM1     # perform a 16Byte swap
1963                 vpxor    TMP1(%rsp), \XMM1, \XMM1          # combine GHASHed value with
1964                                                            # the corresponding ciphertext
1965                 vpshufb  SHUF_MASK(%rip), \XMM2, \XMM2     # perform a 16Byte swap
1966                 vpshufb  SHUF_MASK(%rip), \XMM3, \XMM3     # perform a 16Byte swap
1967                 vpshufb  SHUF_MASK(%rip), \XMM4, \XMM4     # perform a 16Byte swap
1968                 vpshufb  SHUF_MASK(%rip), \XMM5, \XMM5     # perform a 16Byte swap
1969                 vpshufb  SHUF_MASK(%rip), \XMM6, \XMM6     # perform a 16Byte swap
1970                 vpshufb  SHUF_MASK(%rip), \XMM7, \XMM7     # perform a 16Byte swap
1971                 vpshufb  SHUF_MASK(%rip), \XMM8, \XMM8     # perform a 16Byte swap
1972
1973 ###############################################################################
1974
1975 _initial_blocks_done\@:
1976
1977
1978 .endm
1979
1980
1981
1982 # encrypt 8 blocks at a time
1983 # ghash the 8 previously encrypted ciphertext blocks
1984 # arg1, arg3, arg4 are used as pointers only, not modified
1985 # r11 is the data offset value
1986 .macro GHASH_8_ENCRYPT_8_PARALLEL_AVX2 T1 T2 T3 T4 T5 T6 CTR XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 T7 loop_idx ENC_DEC
1987
1988         vmovdqa \XMM1, \T2
1989         vmovdqa \XMM2, TMP2(%rsp)
1990         vmovdqa \XMM3, TMP3(%rsp)
1991         vmovdqa \XMM4, TMP4(%rsp)
1992         vmovdqa \XMM5, TMP5(%rsp)
1993         vmovdqa \XMM6, TMP6(%rsp)
1994         vmovdqa \XMM7, TMP7(%rsp)
1995         vmovdqa \XMM8, TMP8(%rsp)
1996
1997 .if \loop_idx == in_order
1998                 vpaddd  ONE(%rip), \CTR, \XMM1            # INCR CNT
1999                 vpaddd  ONE(%rip), \XMM1, \XMM2
2000                 vpaddd  ONE(%rip), \XMM2, \XMM3
2001                 vpaddd  ONE(%rip), \XMM3, \XMM4
2002                 vpaddd  ONE(%rip), \XMM4, \XMM5
2003                 vpaddd  ONE(%rip), \XMM5, \XMM6
2004                 vpaddd  ONE(%rip), \XMM6, \XMM7
2005                 vpaddd  ONE(%rip), \XMM7, \XMM8
2006                 vmovdqa \XMM8, \CTR
2007
2008                 vpshufb SHUF_MASK(%rip), \XMM1, \XMM1     # perform a 16Byte swap
2009                 vpshufb SHUF_MASK(%rip), \XMM2, \XMM2     # perform a 16Byte swap
2010                 vpshufb SHUF_MASK(%rip), \XMM3, \XMM3     # perform a 16Byte swap
2011                 vpshufb SHUF_MASK(%rip), \XMM4, \XMM4     # perform a 16Byte swap
2012                 vpshufb SHUF_MASK(%rip), \XMM5, \XMM5     # perform a 16Byte swap
2013                 vpshufb SHUF_MASK(%rip), \XMM6, \XMM6     # perform a 16Byte swap
2014                 vpshufb SHUF_MASK(%rip), \XMM7, \XMM7     # perform a 16Byte swap
2015                 vpshufb SHUF_MASK(%rip), \XMM8, \XMM8     # perform a 16Byte swap
2016 .else
2017                 vpaddd  ONEf(%rip), \CTR, \XMM1            # INCR CNT
2018                 vpaddd  ONEf(%rip), \XMM1, \XMM2
2019                 vpaddd  ONEf(%rip), \XMM2, \XMM3
2020                 vpaddd  ONEf(%rip), \XMM3, \XMM4
2021                 vpaddd  ONEf(%rip), \XMM4, \XMM5
2022                 vpaddd  ONEf(%rip), \XMM5, \XMM6
2023                 vpaddd  ONEf(%rip), \XMM6, \XMM7
2024                 vpaddd  ONEf(%rip), \XMM7, \XMM8
2025                 vmovdqa \XMM8, \CTR
2026 .endif
2027
2028
2029         #######################################################################
2030
2031                 vmovdqu (arg1), \T1
2032                 vpxor   \T1, \XMM1, \XMM1
2033                 vpxor   \T1, \XMM2, \XMM2
2034                 vpxor   \T1, \XMM3, \XMM3
2035                 vpxor   \T1, \XMM4, \XMM4
2036                 vpxor   \T1, \XMM5, \XMM5
2037                 vpxor   \T1, \XMM6, \XMM6
2038                 vpxor   \T1, \XMM7, \XMM7
2039                 vpxor   \T1, \XMM8, \XMM8
2040
2041         #######################################################################
2042
2043
2044
2045
2046
2047                 vmovdqu 16*1(arg1), \T1
2048                 vaesenc \T1, \XMM1, \XMM1
2049                 vaesenc \T1, \XMM2, \XMM2
2050                 vaesenc \T1, \XMM3, \XMM3
2051                 vaesenc \T1, \XMM4, \XMM4
2052                 vaesenc \T1, \XMM5, \XMM5
2053                 vaesenc \T1, \XMM6, \XMM6
2054                 vaesenc \T1, \XMM7, \XMM7
2055                 vaesenc \T1, \XMM8, \XMM8
2056
2057                 vmovdqu 16*2(arg1), \T1
2058                 vaesenc \T1, \XMM1, \XMM1
2059                 vaesenc \T1, \XMM2, \XMM2
2060                 vaesenc \T1, \XMM3, \XMM3
2061                 vaesenc \T1, \XMM4, \XMM4
2062                 vaesenc \T1, \XMM5, \XMM5
2063                 vaesenc \T1, \XMM6, \XMM6
2064                 vaesenc \T1, \XMM7, \XMM7
2065                 vaesenc \T1, \XMM8, \XMM8
2066
2067
2068         #######################################################################
2069
2070         vmovdqu         HashKey_8(arg2), \T5
2071         vpclmulqdq      $0x11, \T5, \T2, \T4              # T4 = a1*b1
2072         vpclmulqdq      $0x00, \T5, \T2, \T7              # T7 = a0*b0
2073         vpclmulqdq      $0x01, \T5, \T2, \T6              # T6 = a1*b0
2074         vpclmulqdq      $0x10, \T5, \T2, \T5              # T5 = a0*b1
2075         vpxor           \T5, \T6, \T6
2076
2077                 vmovdqu 16*3(arg1), \T1
2078                 vaesenc \T1, \XMM1, \XMM1
2079                 vaesenc \T1, \XMM2, \XMM2
2080                 vaesenc \T1, \XMM3, \XMM3
2081                 vaesenc \T1, \XMM4, \XMM4
2082                 vaesenc \T1, \XMM5, \XMM5
2083                 vaesenc \T1, \XMM6, \XMM6
2084                 vaesenc \T1, \XMM7, \XMM7
2085                 vaesenc \T1, \XMM8, \XMM8
2086
2087         vmovdqa         TMP2(%rsp), \T1
2088         vmovdqu         HashKey_7(arg2), \T5
2089         vpclmulqdq      $0x11, \T5, \T1, \T3
2090         vpxor           \T3, \T4, \T4
2091
2092         vpclmulqdq      $0x00, \T5, \T1, \T3
2093         vpxor           \T3, \T7, \T7
2094
2095         vpclmulqdq      $0x01, \T5, \T1, \T3
2096         vpxor           \T3, \T6, \T6
2097
2098         vpclmulqdq      $0x10, \T5, \T1, \T3
2099         vpxor           \T3, \T6, \T6
2100
2101                 vmovdqu 16*4(arg1), \T1
2102                 vaesenc \T1, \XMM1, \XMM1
2103                 vaesenc \T1, \XMM2, \XMM2
2104                 vaesenc \T1, \XMM3, \XMM3
2105                 vaesenc \T1, \XMM4, \XMM4
2106                 vaesenc \T1, \XMM5, \XMM5
2107                 vaesenc \T1, \XMM6, \XMM6
2108                 vaesenc \T1, \XMM7, \XMM7
2109                 vaesenc \T1, \XMM8, \XMM8
2110
2111         #######################################################################
2112
2113         vmovdqa         TMP3(%rsp), \T1
2114         vmovdqu         HashKey_6(arg2), \T5
2115         vpclmulqdq      $0x11, \T5, \T1, \T3
2116         vpxor           \T3, \T4, \T4
2117
2118         vpclmulqdq      $0x00, \T5, \T1, \T3
2119         vpxor           \T3, \T7, \T7
2120
2121         vpclmulqdq      $0x01, \T5, \T1, \T3
2122         vpxor           \T3, \T6, \T6
2123
2124         vpclmulqdq      $0x10, \T5, \T1, \T3
2125         vpxor           \T3, \T6, \T6
2126
2127                 vmovdqu 16*5(arg1), \T1
2128                 vaesenc \T1, \XMM1, \XMM1
2129                 vaesenc \T1, \XMM2, \XMM2
2130                 vaesenc \T1, \XMM3, \XMM3
2131                 vaesenc \T1, \XMM4, \XMM4
2132                 vaesenc \T1, \XMM5, \XMM5
2133                 vaesenc \T1, \XMM6, \XMM6
2134                 vaesenc \T1, \XMM7, \XMM7
2135                 vaesenc \T1, \XMM8, \XMM8
2136
2137         vmovdqa         TMP4(%rsp), \T1
2138         vmovdqu         HashKey_5(arg2), \T5
2139         vpclmulqdq      $0x11, \T5, \T1, \T3
2140         vpxor           \T3, \T4, \T4
2141
2142         vpclmulqdq      $0x00, \T5, \T1, \T3
2143         vpxor           \T3, \T7, \T7
2144
2145         vpclmulqdq      $0x01, \T5, \T1, \T3
2146         vpxor           \T3, \T6, \T6
2147
2148         vpclmulqdq      $0x10, \T5, \T1, \T3
2149         vpxor           \T3, \T6, \T6
2150
2151                 vmovdqu 16*6(arg1), \T1
2152                 vaesenc \T1, \XMM1, \XMM1
2153                 vaesenc \T1, \XMM2, \XMM2
2154                 vaesenc \T1, \XMM3, \XMM3
2155                 vaesenc \T1, \XMM4, \XMM4
2156                 vaesenc \T1, \XMM5, \XMM5
2157                 vaesenc \T1, \XMM6, \XMM6
2158                 vaesenc \T1, \XMM7, \XMM7
2159                 vaesenc \T1, \XMM8, \XMM8
2160
2161
2162         vmovdqa         TMP5(%rsp), \T1
2163         vmovdqu         HashKey_4(arg2), \T5
2164         vpclmulqdq      $0x11, \T5, \T1, \T3
2165         vpxor           \T3, \T4, \T4
2166
2167         vpclmulqdq      $0x00, \T5, \T1, \T3
2168         vpxor           \T3, \T7, \T7
2169
2170         vpclmulqdq      $0x01, \T5, \T1, \T3
2171         vpxor           \T3, \T6, \T6
2172
2173         vpclmulqdq      $0x10, \T5, \T1, \T3
2174         vpxor           \T3, \T6, \T6
2175
2176                 vmovdqu 16*7(arg1), \T1
2177                 vaesenc \T1, \XMM1, \XMM1
2178                 vaesenc \T1, \XMM2, \XMM2
2179                 vaesenc \T1, \XMM3, \XMM3
2180                 vaesenc \T1, \XMM4, \XMM4
2181                 vaesenc \T1, \XMM5, \XMM5
2182                 vaesenc \T1, \XMM6, \XMM6
2183                 vaesenc \T1, \XMM7, \XMM7
2184                 vaesenc \T1, \XMM8, \XMM8
2185
2186         vmovdqa         TMP6(%rsp), \T1
2187         vmovdqu         HashKey_3(arg2), \T5
2188         vpclmulqdq      $0x11, \T5, \T1, \T3
2189         vpxor           \T3, \T4, \T4
2190
2191         vpclmulqdq      $0x00, \T5, \T1, \T3
2192         vpxor           \T3, \T7, \T7
2193
2194         vpclmulqdq      $0x01, \T5, \T1, \T3
2195         vpxor           \T3, \T6, \T6
2196
2197         vpclmulqdq      $0x10, \T5, \T1, \T3
2198         vpxor           \T3, \T6, \T6
2199
2200                 vmovdqu 16*8(arg1), \T1
2201                 vaesenc \T1, \XMM1, \XMM1
2202                 vaesenc \T1, \XMM2, \XMM2
2203                 vaesenc \T1, \XMM3, \XMM3
2204                 vaesenc \T1, \XMM4, \XMM4
2205                 vaesenc \T1, \XMM5, \XMM5
2206                 vaesenc \T1, \XMM6, \XMM6
2207                 vaesenc \T1, \XMM7, \XMM7
2208                 vaesenc \T1, \XMM8, \XMM8
2209
2210         vmovdqa         TMP7(%rsp), \T1
2211         vmovdqu         HashKey_2(arg2), \T5
2212         vpclmulqdq      $0x11, \T5, \T1, \T3
2213         vpxor           \T3, \T4, \T4
2214
2215         vpclmulqdq      $0x00, \T5, \T1, \T3
2216         vpxor           \T3, \T7, \T7
2217
2218         vpclmulqdq      $0x01, \T5, \T1, \T3
2219         vpxor           \T3, \T6, \T6
2220
2221         vpclmulqdq      $0x10, \T5, \T1, \T3
2222         vpxor           \T3, \T6, \T6
2223
2224
2225         #######################################################################
2226
2227                 vmovdqu 16*9(arg1), \T5
2228                 vaesenc \T5, \XMM1, \XMM1
2229                 vaesenc \T5, \XMM2, \XMM2
2230                 vaesenc \T5, \XMM3, \XMM3
2231                 vaesenc \T5, \XMM4, \XMM4
2232                 vaesenc \T5, \XMM5, \XMM5
2233                 vaesenc \T5, \XMM6, \XMM6
2234                 vaesenc \T5, \XMM7, \XMM7
2235                 vaesenc \T5, \XMM8, \XMM8
2236
2237         vmovdqa         TMP8(%rsp), \T1
2238         vmovdqu         HashKey(arg2), \T5
2239
2240         vpclmulqdq      $0x00, \T5, \T1, \T3
2241         vpxor           \T3, \T7, \T7
2242
2243         vpclmulqdq      $0x01, \T5, \T1, \T3
2244         vpxor           \T3, \T6, \T6
2245
2246         vpclmulqdq      $0x10, \T5, \T1, \T3
2247         vpxor           \T3, \T6, \T6
2248
2249         vpclmulqdq      $0x11, \T5, \T1, \T3
2250         vpxor           \T3, \T4, \T1
2251
2252
2253                 vmovdqu 16*10(arg1), \T5
2254
2255         i = 0
2256         j = 1
2257         setreg
2258 .rep 8
2259                 vpxor   16*i(arg4, %r11), \T5, \T2
2260                 .if \ENC_DEC == ENC
2261                 vaesenclast     \T2, reg_j, reg_j
2262                 .else
2263                 vaesenclast     \T2, reg_j, \T3
2264                 vmovdqu 16*i(arg4, %r11), reg_j
2265                 vmovdqu \T3, 16*i(arg3, %r11)
2266                 .endif
2267         i = (i+1)
2268         j = (j+1)
2269         setreg
2270 .endr
2271         #######################################################################
2272
2273
2274         vpslldq $8, \T6, \T3                            # shift-L T3 2 DWs
2275         vpsrldq $8, \T6, \T6                            # shift-R T2 2 DWs
2276         vpxor   \T3, \T7, \T7
2277         vpxor   \T6, \T1, \T1                           # accumulate the results in T1:T7
2278
2279
2280
2281         #######################################################################
2282         #first phase of the reduction
2283         vmovdqa         POLY2(%rip), \T3
2284
2285         vpclmulqdq      $0x01, \T7, \T3, \T2
2286         vpslldq         $8, \T2, \T2                    # shift-L xmm2 2 DWs
2287
2288         vpxor           \T2, \T7, \T7                   # first phase of the reduction complete
2289         #######################################################################
2290                 .if \ENC_DEC == ENC
2291                 vmovdqu  \XMM1, 16*0(arg3,%r11)         # Write to the Ciphertext buffer
2292                 vmovdqu  \XMM2, 16*1(arg3,%r11)         # Write to the Ciphertext buffer
2293                 vmovdqu  \XMM3, 16*2(arg3,%r11)         # Write to the Ciphertext buffer
2294                 vmovdqu  \XMM4, 16*3(arg3,%r11)         # Write to the Ciphertext buffer
2295                 vmovdqu  \XMM5, 16*4(arg3,%r11)         # Write to the Ciphertext buffer
2296                 vmovdqu  \XMM6, 16*5(arg3,%r11)         # Write to the Ciphertext buffer
2297                 vmovdqu  \XMM7, 16*6(arg3,%r11)         # Write to the Ciphertext buffer
2298                 vmovdqu  \XMM8, 16*7(arg3,%r11)         # Write to the Ciphertext buffer
2299                 .endif
2300
2301         #######################################################################
2302         #second phase of the reduction
2303         vpclmulqdq      $0x00, \T7, \T3, \T2
2304         vpsrldq         $4, \T2, \T2                    # shift-R xmm2 1 DW (Shift-R only 1-DW to obtain 2-DWs shift-R)
2305
2306         vpclmulqdq      $0x10, \T7, \T3, \T4
2307         vpslldq         $4, \T4, \T4                    # shift-L xmm0 1 DW (Shift-L 1-DW to obtain result with no shifts)
2308
2309         vpxor           \T2, \T4, \T4                   # second phase of the reduction complete
2310         #######################################################################
2311         vpxor           \T4, \T1, \T1                   # the result is in T1
2312
2313                 vpshufb SHUF_MASK(%rip), \XMM1, \XMM1   # perform a 16Byte swap
2314                 vpshufb SHUF_MASK(%rip), \XMM2, \XMM2   # perform a 16Byte swap
2315                 vpshufb SHUF_MASK(%rip), \XMM3, \XMM3   # perform a 16Byte swap
2316                 vpshufb SHUF_MASK(%rip), \XMM4, \XMM4   # perform a 16Byte swap
2317                 vpshufb SHUF_MASK(%rip), \XMM5, \XMM5   # perform a 16Byte swap
2318                 vpshufb SHUF_MASK(%rip), \XMM6, \XMM6   # perform a 16Byte swap
2319                 vpshufb SHUF_MASK(%rip), \XMM7, \XMM7   # perform a 16Byte swap
2320                 vpshufb SHUF_MASK(%rip), \XMM8, \XMM8   # perform a 16Byte swap
2321
2322
2323         vpxor   \T1, \XMM1, \XMM1
2324
2325
2326
2327 .endm
2328
2329
2330 # GHASH the last 4 ciphertext blocks.
2331 .macro  GHASH_LAST_8_AVX2 T1 T2 T3 T4 T5 T6 T7 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8
2332
2333         ## Karatsuba Method
2334
2335         vmovdqu         HashKey_8(arg2), \T5
2336
2337         vpshufd         $0b01001110, \XMM1, \T2
2338         vpshufd         $0b01001110, \T5, \T3
2339         vpxor           \XMM1, \T2, \T2
2340         vpxor           \T5, \T3, \T3
2341
2342         vpclmulqdq      $0x11, \T5, \XMM1, \T6
2343         vpclmulqdq      $0x00, \T5, \XMM1, \T7
2344
2345         vpclmulqdq      $0x00, \T3, \T2, \XMM1
2346
2347         ######################
2348
2349         vmovdqu         HashKey_7(arg2), \T5
2350         vpshufd         $0b01001110, \XMM2, \T2
2351         vpshufd         $0b01001110, \T5, \T3
2352         vpxor           \XMM2, \T2, \T2
2353         vpxor           \T5, \T3, \T3
2354
2355         vpclmulqdq      $0x11, \T5, \XMM2, \T4
2356         vpxor           \T4, \T6, \T6
2357
2358         vpclmulqdq      $0x00, \T5, \XMM2, \T4
2359         vpxor           \T4, \T7, \T7
2360
2361         vpclmulqdq      $0x00, \T3, \T2, \T2
2362
2363         vpxor           \T2, \XMM1, \XMM1
2364
2365         ######################
2366
2367         vmovdqu         HashKey_6(arg2), \T5
2368         vpshufd         $0b01001110, \XMM3, \T2
2369         vpshufd         $0b01001110, \T5, \T3
2370         vpxor           \XMM3, \T2, \T2
2371         vpxor           \T5, \T3, \T3
2372
2373         vpclmulqdq      $0x11, \T5, \XMM3, \T4
2374         vpxor           \T4, \T6, \T6
2375
2376         vpclmulqdq      $0x00, \T5, \XMM3, \T4
2377         vpxor           \T4, \T7, \T7
2378
2379         vpclmulqdq      $0x00, \T3, \T2, \T2
2380
2381         vpxor           \T2, \XMM1, \XMM1
2382
2383         ######################
2384
2385         vmovdqu         HashKey_5(arg2), \T5
2386         vpshufd         $0b01001110, \XMM4, \T2
2387         vpshufd         $0b01001110, \T5, \T3
2388         vpxor           \XMM4, \T2, \T2
2389         vpxor           \T5, \T3, \T3
2390
2391         vpclmulqdq      $0x11, \T5, \XMM4, \T4
2392         vpxor           \T4, \T6, \T6
2393
2394         vpclmulqdq      $0x00, \T5, \XMM4, \T4
2395         vpxor           \T4, \T7, \T7
2396
2397         vpclmulqdq      $0x00, \T3, \T2, \T2
2398
2399         vpxor           \T2, \XMM1, \XMM1
2400
2401         ######################
2402
2403         vmovdqu         HashKey_4(arg2), \T5
2404         vpshufd         $0b01001110, \XMM5, \T2
2405         vpshufd         $0b01001110, \T5, \T3
2406         vpxor           \XMM5, \T2, \T2
2407         vpxor           \T5, \T3, \T3
2408
2409         vpclmulqdq      $0x11, \T5, \XMM5, \T4
2410         vpxor           \T4, \T6, \T6
2411
2412         vpclmulqdq      $0x00, \T5, \XMM5, \T4
2413         vpxor           \T4, \T7, \T7
2414
2415         vpclmulqdq      $0x00, \T3, \T2, \T2
2416
2417         vpxor           \T2, \XMM1, \XMM1
2418
2419         ######################
2420
2421         vmovdqu         HashKey_3(arg2), \T5
2422         vpshufd         $0b01001110, \XMM6, \T2
2423         vpshufd         $0b01001110, \T5, \T3
2424         vpxor           \XMM6, \T2, \T2
2425         vpxor           \T5, \T3, \T3
2426
2427         vpclmulqdq      $0x11, \T5, \XMM6, \T4
2428         vpxor           \T4, \T6, \T6
2429
2430         vpclmulqdq      $0x00, \T5, \XMM6, \T4
2431         vpxor           \T4, \T7, \T7
2432
2433         vpclmulqdq      $0x00, \T3, \T2, \T2
2434
2435         vpxor           \T2, \XMM1, \XMM1
2436
2437         ######################
2438
2439         vmovdqu         HashKey_2(arg2), \T5
2440         vpshufd         $0b01001110, \XMM7, \T2
2441         vpshufd         $0b01001110, \T5, \T3
2442         vpxor           \XMM7, \T2, \T2
2443         vpxor           \T5, \T3, \T3
2444
2445         vpclmulqdq      $0x11, \T5, \XMM7, \T4
2446         vpxor           \T4, \T6, \T6
2447
2448         vpclmulqdq      $0x00, \T5, \XMM7, \T4
2449         vpxor           \T4, \T7, \T7
2450
2451         vpclmulqdq      $0x00, \T3, \T2, \T2
2452
2453         vpxor           \T2, \XMM1, \XMM1
2454
2455         ######################
2456
2457         vmovdqu         HashKey(arg2), \T5
2458         vpshufd         $0b01001110, \XMM8, \T2
2459         vpshufd         $0b01001110, \T5, \T3
2460         vpxor           \XMM8, \T2, \T2
2461         vpxor           \T5, \T3, \T3
2462
2463         vpclmulqdq      $0x11, \T5, \XMM8, \T4
2464         vpxor           \T4, \T6, \T6
2465
2466         vpclmulqdq      $0x00, \T5, \XMM8, \T4
2467         vpxor           \T4, \T7, \T7
2468
2469         vpclmulqdq      $0x00, \T3, \T2, \T2
2470
2471         vpxor           \T2, \XMM1, \XMM1
2472         vpxor           \T6, \XMM1, \XMM1
2473         vpxor           \T7, \XMM1, \T2
2474
2475
2476
2477
2478         vpslldq $8, \T2, \T4
2479         vpsrldq $8, \T2, \T2
2480
2481         vpxor   \T4, \T7, \T7
2482         vpxor   \T2, \T6, \T6                      # <T6:T7> holds the result of the
2483                                                    # accumulated carry-less multiplications
2484
2485         #######################################################################
2486         #first phase of the reduction
2487         vmovdqa         POLY2(%rip), \T3
2488
2489         vpclmulqdq      $0x01, \T7, \T3, \T2
2490         vpslldq         $8, \T2, \T2               # shift-L xmm2 2 DWs
2491
2492         vpxor           \T2, \T7, \T7              # first phase of the reduction complete
2493         #######################################################################
2494
2495
2496         #second phase of the reduction
2497         vpclmulqdq      $0x00, \T7, \T3, \T2
2498         vpsrldq         $4, \T2, \T2               # shift-R T2 1 DW (Shift-R only 1-DW to obtain 2-DWs shift-R)
2499
2500         vpclmulqdq      $0x10, \T7, \T3, \T4
2501         vpslldq         $4, \T4, \T4               # shift-L T4 1 DW (Shift-L 1-DW to obtain result with no shifts)
2502
2503         vpxor           \T2, \T4, \T4              # second phase of the reduction complete
2504         #######################################################################
2505         vpxor           \T4, \T6, \T6              # the result is in T6
2506 .endm
2507
2508
2509
2510 #############################################################
2511 #void   aesni_gcm_precomp_avx_gen4
2512 #        (gcm_data     *my_ctx_data,
2513 #         gcm_context_data *data,
2514 #        u8     *hash_subkey)# /* H, the Hash sub key input.
2515 #                               Data starts on a 16-byte boundary. */
2516 #############################################################
2517 ENTRY(aesni_gcm_precomp_avx_gen4)
2518         FUNC_SAVE
2519
2520         vmovdqu  (arg3), %xmm6                # xmm6 = HashKey
2521
2522         vpshufb  SHUF_MASK(%rip), %xmm6, %xmm6
2523         ###############  PRECOMPUTATION of HashKey<<1 mod poly from the HashKey
2524         vmovdqa  %xmm6, %xmm2
2525         vpsllq   $1, %xmm6, %xmm6
2526         vpsrlq   $63, %xmm2, %xmm2
2527         vmovdqa  %xmm2, %xmm1
2528         vpslldq  $8, %xmm2, %xmm2
2529         vpsrldq  $8, %xmm1, %xmm1
2530         vpor     %xmm2, %xmm6, %xmm6
2531         #reduction
2532         vpshufd  $0b00100100, %xmm1, %xmm2
2533         vpcmpeqd TWOONE(%rip), %xmm2, %xmm2
2534         vpand    POLY(%rip), %xmm2, %xmm2
2535         vpxor    %xmm2, %xmm6, %xmm6          # xmm6 holds the HashKey<<1 mod poly
2536         #######################################################################
2537         vmovdqu  %xmm6, HashKey(arg2)         # store HashKey<<1 mod poly
2538
2539
2540         PRECOMPUTE_AVX2  %xmm6, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5
2541
2542         FUNC_RESTORE
2543         ret
2544 ENDPROC(aesni_gcm_precomp_avx_gen4)
2545
2546
2547 ###############################################################################
2548 #void   aesni_gcm_enc_avx_gen4(
2549 #        gcm_data        *my_ctx_data,     /* aligned to 16 Bytes */
2550 #        gcm_context_data *data,
2551 #        u8      *out, /* Ciphertext output. Encrypt in-place is allowed.  */
2552 #        const   u8 *in, /* Plaintext input */
2553 #        u64     plaintext_len, /* Length of data in Bytes for encryption. */
2554 #        u8      *iv, /* Pre-counter block j0: 4 byte salt
2555 #                       (from Security Association) concatenated with 8 byte
2556 #                        Initialisation Vector (from IPSec ESP Payload)
2557 #                        concatenated with 0x00000001. 16-byte aligned pointer. */
2558 #        const   u8 *aad, /* Additional Authentication Data (AAD)*/
2559 #        u64     aad_len, /* Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 Bytes */
2560 #        u8      *auth_tag, /* Authenticated Tag output. */
2561 #        u64     auth_tag_len)# /* Authenticated Tag Length in bytes.
2562 #                               Valid values are 16 (most likely), 12 or 8. */
2563 ###############################################################################
2564 ENTRY(aesni_gcm_enc_avx_gen4)
2565         FUNC_SAVE
2566         GCM_ENC_DEC INITIAL_BLOCKS_AVX2 GHASH_8_ENCRYPT_8_PARALLEL_AVX2 GHASH_LAST_8_AVX2 GHASH_MUL_AVX2 ENC
2567         FUNC_RESTORE
2568         ret
2569 ENDPROC(aesni_gcm_enc_avx_gen4)
2570
2571 ###############################################################################
2572 #void   aesni_gcm_dec_avx_gen4(
2573 #        gcm_data        *my_ctx_data,     /* aligned to 16 Bytes */
2574 #        gcm_context_data *data,
2575 #        u8      *out, /* Plaintext output. Decrypt in-place is allowed.  */
2576 #        const   u8 *in, /* Ciphertext input */
2577 #        u64     plaintext_len, /* Length of data in Bytes for encryption. */
2578 #        u8      *iv, /* Pre-counter block j0: 4 byte salt
2579 #                       (from Security Association) concatenated with 8 byte
2580 #                       Initialisation Vector (from IPSec ESP Payload)
2581 #                       concatenated with 0x00000001. 16-byte aligned pointer. */
2582 #        const   u8 *aad, /* Additional Authentication Data (AAD)*/
2583 #        u64     aad_len, /* Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 Bytes */
2584 #        u8      *auth_tag, /* Authenticated Tag output. */
2585 #        u64     auth_tag_len)# /* Authenticated Tag Length in bytes.
2586 #                               Valid values are 16 (most likely), 12 or 8. */
2587 ###############################################################################
2588 ENTRY(aesni_gcm_dec_avx_gen4)
2589         FUNC_SAVE
2590         GCM_ENC_DEC INITIAL_BLOCKS_AVX2 GHASH_8_ENCRYPT_8_PARALLEL_AVX2 GHASH_LAST_8_AVX2 GHASH_MUL_AVX2 DEC
2591         FUNC_RESTORE
2592         ret
2593 ENDPROC(aesni_gcm_dec_avx_gen4)
2594
2595 #endif /* CONFIG_AS_AVX2 */