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