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