crypto/aes/asm/aesni-x86_64.pl

   1 #!/usr/bin/env perl
   2 #
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
   5 # project. The module is, however, dual licensed under OpenSSL and
   6 # CRYPTOGAMS licenses depending on where you obtain it. For further
   7 # details see http://www.openssl.org/~appro/cryptogams/.
   8 # ====================================================================
   9 #
  10 # This module implements support for Intel AES-NI extension. In
  11 # OpenSSL context it's used with Intel engine, but can also be used as
  12 # drop-in replacement for crypto/aes/asm/aes-x86_64.pl [see below for
  13 # details].
  14 #
  15 # Performance.
  16 #
  17 # Given aes(enc|dec) instructions' latency asymptotic performance for
  18 # non-parallelizable modes such as CBC encrypt is 3.75 cycles per byte
  19 # processed with 128-bit key. And given their throughput asymptotic
  20 # performance for parallelizable modes is 1.25 cycles per byte. Being
  21 # asymptotic limit is not something you commonly achieve in reality,
  22 # but how close does one get? Below are results collected for
  23 # different modes and block sized. Pairs of numbers are for en-/
  24 # decryption.
  25 #
  26 #       16-byte     64-byte     256-byte    1-KB        8-KB
  27 # ECB   4.25/4.25   1.38/1.38   1.28/1.28   1.26/1.26   1.26/1.26
  28 # CTR   5.42/5.42   1.92/1.92   1.44/1.44   1.28/1.28   1.26/1.26
  29 # CBC   4.38/4.43   4.15/1.43   4.07/1.32   4.07/1.29   4.06/1.28
  30 # CCM   5.66/9.42   4.42/5.41   4.16/4.40   4.09/4.15   4.06/4.07
  31 # OFB   5.42/5.42   4.64/4.64   4.44/4.44   4.39/4.39   4.38/4.38
  32 # CFB   5.73/5.85   5.56/5.62   5.48/5.56   5.47/5.55   5.47/5.55
  33 #
  34 # ECB, CTR, CBC and CCM results are free from EVP overhead. This means
  35 # that otherwise used 'openssl speed -evp aes-128-??? -engine aesni
  36 # [-decrypt]' will exhibit 10-15% worse results for smaller blocks.
  37 # The results were collected with specially crafted speed.c benchmark
  38 # in order to compare them with results reported in "Intel Advanced
  39 # Encryption Standard (AES) New Instruction Set" White Paper Revision
  40 # 3.0 dated May 2010. All above results are consistently better. This
  41 # module also provides better performance for block sizes smaller than
  42 # 128 bytes in points *not* represented in the above table.
  43 #
  44 # Looking at the results for 8-KB buffer.
  45 #
  46 # CFB and OFB results are far from the limit, because implementation
  47 # uses "generic" CRYPTO_[c|o]fb128_encrypt interfaces relying on
  48 # single-block aesni_encrypt, which is not the most optimal way to go.
  49 # CBC encrypt result is unexpectedly high and there is no documented
  50 # explanation for it. Seemingly there is a small penalty for feeding
  51 # the result back to AES unit the way it's done in CBC mode. There is
  52 # nothing one can do and the result appears optimal. CCM result is
  53 # identical to CBC, because CBC-MAC is essentially CBC encrypt without
  54 # saving output. CCM CTR "stays invisible," because it's neatly
  55 # interleaved wih CBC-MAC. This provides ~30% improvement over
  56 # "straghtforward" CCM implementation with CTR and CBC-MAC performed
  57 # disjointly. Parallelizable modes practically achieve the theoretical
  58 # limit.
  59 #
  60 # Looking at how results vary with buffer size.
  61 #
  62 # Curves are practically saturated at 1-KB buffer size. In most cases
  63 # "256-byte" performance is >95%, and "64-byte" is ~90% of "8-KB" one.
  64 # CTR curve doesn't follow this pattern and is "slowest" changing one
  65 # with "256-byte" result being 87% of "8-KB." This is because overhead
  66 # in CTR mode is most computationally intensive. Small-block CCM
  67 # decrypt is slower than encrypt, because first CTR and last CBC-MAC
  68 # iterations can't be interleaved.
  69 #
  70 # Results for 192- and 256-bit keys.
  71 #
  72 # EVP-free results were observed to scale perfectly with number of
  73 # rounds for larger block sizes, i.e. 192-bit result being 10/12 times
  74 # lower and 256-bit one - 10/14. Well, in CBC encrypt case differences
  75 # are a tad smaller, because the above mentioned penalty biases all
  76 # results by same constant value. In similar way function call
  77 # overhead affects small-block performance, as well as OFB and CFB
  78 # results. Differences are not large, most common coefficients are
  79 # 10/11.7 and 10/13.4 (as opposite to 10/12.0 and 10/14.0), but one
  80 # observe even 10/11.2 and 10/12.4 (CTR, OFB, CFB)...
  81
  82 $PREFIX="aesni";        # if $PREFIX is set to "AES", the script
  83                         # generates drop-in replacement for
  84                         # crypto/aes/asm/aes-x86_64.pl:-)
  85
  86 $flavour = shift;
  87 $output  = shift;
  88 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
  89
  90 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
  91
  92 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  93 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
  94 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
  95 die "can't locate x86_64-xlate.pl";
  96
  97 open STDOUT,"| $^X $xlate $flavour $output";
  98
  99 $movkey = $PREFIX eq "aesni" ? "movaps" : "movups";
 100 @_4args=$win64? ("%rcx","%rdx","%r8", "%r9") :  # Win64 order
 101                 ("%rdi","%rsi","%rdx","%rcx");  # Unix order
 102
 103 $code=".text\n";
 104
 105 $rounds="%eax"; # input to and changed by aesni_[en|de]cryptN !!!
 106 # this is natural Unix argument order for public $PREFIX_[ecb|cbc]_encrypt ...
 107 $inp="%rdi";
 108 $out="%rsi";
 109 $len="%rdx";
 110 $key="%rcx";    # input to and changed by aesni_[en|de]cryptN !!!
 111 $ivp="%r8";     # cbc, ctr, ...
 112
 113 $rnds_="%r10d"; # backup copy for $rounds
 114 $key_="%r11";   # backup copy for $key
 115
 116 # %xmm register layout
 117 $inout0="%xmm0";        $inout1="%xmm1";
 118 $inout2="%xmm2";        $inout3="%xmm3";
 119 $rndkey0="%xmm4";       $rndkey1="%xmm5";
 120
 121 $iv="%xmm6";            $in0="%xmm7";   # used in CBC decrypt, CTR, ...
 122 $in1="%xmm8";           $in2="%xmm9";
 123 \f
 124 # Inline version of internal aesni_[en|de]crypt1.
 125 #
 126 # Why folded loop? Because aes[enc|dec] is slow enough to accommodate
 127 # cycles which take care of loop variables...
 128 { my $sn;
 129 sub aesni_generate1 {
 130 my ($p,$key,$rounds,$inout)=@_; $inout=$inout0 if (!defined($inout));
 131 ++$sn;
 132 $code.=<<___;
 133         movdqu  ($key),$rndkey0
 134         $movkey 16($key),$rndkey1
 135         lea     32($key),$key
 136         pxor    $rndkey0,$inout
 137 .Loop_${p}1_$sn:
 138         aes${p} $rndkey1,$inout
 139         dec     $rounds
 140         $movkey ($key),$rndkey1
 141         lea     16($key),$key
 142         jnz     .Loop_${p}1_$sn # loop body is 16 bytes
 143         aes${p}last     $rndkey1,$inout
 144 ___
 145 }}
 146 # void $PREFIX_[en|de]crypt (const void *inp,void *out,const AES_KEY *key);
 147 #
 148 { my ($inp,$out,$key) = @_4args;
 149
 150 $code.=<<___;
 151 .globl  ${PREFIX}_encrypt
 152 .type   ${PREFIX}_encrypt,\@abi-omnipotent
 153 .align  16
 154 ${PREFIX}_encrypt:
 155         movdqu  ($inp),$inout0          # load input
 156         mov     240($key),$rounds       # pull $rounds
 157 ___
 158         &aesni_generate1("enc",$key,$rounds);
 159 $code.=<<___;
 160         movups  $inout0,($out)          # output
 161         ret
 162 .size   ${PREFIX}_encrypt,.-${PREFIX}_encrypt
 163
 164 .globl  ${PREFIX}_decrypt
 165 .type   ${PREFIX}_decrypt,\@abi-omnipotent
 166 .align  16
 167 ${PREFIX}_decrypt:
 168         movdqu  ($inp),$inout0          # load input
 169         mov     240($key),$rounds       # pull $rounds
 170 ___
 171         &aesni_generate1("dec",$key,$rounds);
 172 $code.=<<___;
 173         movups  $inout0,($out)          # output
 174         ret
 175 .size   ${PREFIX}_decrypt, .-${PREFIX}_decrypt
 176 ___
 177 }
 178 \f
 179 # _aesni_[en|de]crypt[34] are private interfaces, N denotes interleave
 180 # factor. Why 3x subroutine is used in loops? Even though aes[enc|dec]
 181 # latency is 6, it turned out that it can be scheduled only every
 182 # *second* cycle. Thus 3x interleave is the one providing optimal
 183 # utilization, i.e. when subroutine's throughput is virtually same as
 184 # of non-interleaved subroutine [for number of input blocks up to 3].
 185 # This is why it makes no sense to implement 2x subroutine. As soon
 186 # as/if Intel improves throughput by making it possible to schedule
 187 # the instructions in question *every* cycles I would have to
 188 # implement 6x interleave and use it in loop...
 189 sub aesni_generate3 {
 190 my $dir=shift;
 191 # As already mentioned it takes in $key and $rounds, which are *not*
 192 # preserved. $inout[0-2] is cipher/clear text...
 193 $code.=<<___;
 194 .type   _aesni_${dir}rypt3,\@abi-omnipotent
 195 .align  16
 196 _aesni_${dir}rypt3:
 197         $movkey ($key),$rndkey0
 198         shr     \$1,$rounds
 199         $movkey 16($key),$rndkey1
 200         lea     32($key),$key
 201         pxor    $rndkey0,$inout0
 202         pxor    $rndkey0,$inout1
 203         pxor    $rndkey0,$inout2
 204         $movkey         ($key),$rndkey0
 205
 206 .L${dir}_loop3:
 207         aes${dir}       $rndkey1,$inout0
 208         aes${dir}       $rndkey1,$inout1
 209         dec             $rounds
 210         aes${dir}       $rndkey1,$inout2
 211         $movkey         16($key),$rndkey1
 212         aes${dir}       $rndkey0,$inout0
 213         aes${dir}       $rndkey0,$inout1
 214         lea             32($key),$key
 215         aes${dir}       $rndkey0,$inout2
 216         $movkey         ($key),$rndkey0
 217         jnz             .L${dir}_loop3
 218
 219         aes${dir}       $rndkey1,$inout0
 220         aes${dir}       $rndkey1,$inout1
 221         aes${dir}       $rndkey1,$inout2
 222         aes${dir}last   $rndkey0,$inout0
 223         aes${dir}last   $rndkey0,$inout1
 224         aes${dir}last   $rndkey0,$inout2
 225         ret
 226 .size   _aesni_${dir}rypt3,.-_aesni_${dir}rypt3
 227 ___
 228 }
 229 # 4x interleave is implemented to improve small block performance,
 230 # most notably [and naturally] 4 block by ~30%. One can argue that one
 231 # should have implemented 5x as well, but improvement would be <20%,
 232 # so it's not worth it...
 233 sub aesni_generate4 {
 234 my $dir=shift;
 235 # As already mentioned it takes in $key and $rounds, which are *not*
 236 # preserved. $inout[0-3] is cipher/clear text...
 237 $code.=<<___;
 238 .type   _aesni_${dir}rypt4,\@abi-omnipotent
 239 .align  16
 240 _aesni_${dir}rypt4:
 241         $movkey ($key),$rndkey0
 242         shr     \$1,$rounds
 243         $movkey 16($key),$rndkey1
 244         lea     32($key),$key
 245         pxor    $rndkey0,$inout0
 246         pxor    $rndkey0,$inout1
 247         pxor    $rndkey0,$inout2
 248         pxor    $rndkey0,$inout3
 249         $movkey         ($key),$rndkey0
 250
 251 .L${dir}_loop4:
 252         aes${dir}       $rndkey1,$inout0
 253         aes${dir}       $rndkey1,$inout1
 254         dec             $rounds
 255         aes${dir}       $rndkey1,$inout2
 256         aes${dir}       $rndkey1,$inout3
 257         $movkey         16($key),$rndkey1
 258         aes${dir}       $rndkey0,$inout0
 259         aes${dir}       $rndkey0,$inout1
 260         lea             32($key),$key
 261         aes${dir}       $rndkey0,$inout2
 262         aes${dir}       $rndkey0,$inout3
 263         $movkey         ($key),$rndkey0
 264         jnz             .L${dir}_loop4
 265
 266         aes${dir}       $rndkey1,$inout0
 267         aes${dir}       $rndkey1,$inout1
 268         aes${dir}       $rndkey1,$inout2
 269         aes${dir}       $rndkey1,$inout3
 270         aes${dir}last   $rndkey0,$inout0
 271         aes${dir}last   $rndkey0,$inout1
 272         aes${dir}last   $rndkey0,$inout2
 273         aes${dir}last   $rndkey0,$inout3
 274         ret
 275 .size   _aesni_${dir}rypt4,.-_aesni_${dir}rypt4
 276 ___
 277 }
 278 &aesni_generate3("enc") if ($PREFIX eq "aesni");
 279 &aesni_generate3("dec");
 280 &aesni_generate4("enc") if ($PREFIX eq "aesni");
 281 &aesni_generate4("dec");
 282 \f
 283 if ($PREFIX eq "aesni") {
 284 ########################################################################
 285 # void aesni_ecb_encrypt (const void *in, void *out,
 286 #                         size_t length, const AES_KEY *key,
 287 #                         int enc);
 288 $code.=<<___;
 289 .globl  aesni_ecb_encrypt
 290 .type   aesni_ecb_encrypt,\@function,5
 291 .align  16
 292 aesni_ecb_encrypt:
 293         cmp     \$16,$len               # check length
 294         jb      .Lecb_ret
 295
 296         mov     240($key),$rounds       # pull $rounds
 297         and     \$-16,$len
 298         mov     $key,$key_              # backup $key
 299         mov     $rounds,$rnds_          # backup $rounds
 300         test    %r8d,%r8d               # 5th argument
 301         jz      .Lecb_decrypt
 302 #--------------------------- ECB ENCRYPT ------------------------------#
 303         cmp     \$0x40,$len
 304         jbe     .Lecb_enc_tail
 305         sub     \$0x40,$len
 306         jmp     .Lecb_enc_loop3
 307 .align 16
 308 .Lecb_enc_loop3:
 309         movups  ($inp),$inout0
 310         movups  0x10($inp),$inout1
 311         movups  0x20($inp),$inout2
 312         call    _aesni_encrypt3
 313         lea     0x30($inp),$inp
 314         movups  $inout0,($out)
 315         mov     $rnds_,$rounds          # restore $rounds
 316         movups  $inout1,0x10($out)
 317         mov     $key_,$key              # restore $key
 318         movups  $inout2,0x20($out)
 319         lea     0x30($out),$out
 320         sub     \$0x30,$len
 321         ja      .Lecb_enc_loop3
 322
 323         add     \$0x40,$len
 324 .Lecb_enc_tail:
 325         movups  ($inp),$inout0
 326         cmp     \$0x20,$len
 327         jb      .Lecb_enc_one
 328         movups  0x10($inp),$inout1
 329         je      .Lecb_enc_two
 330         movups  0x20($inp),$inout2
 331         cmp     \$0x30,$len
 332         je      .Lecb_enc_three
 333         movups  0x30($inp),$inout3
 334         call    _aesni_encrypt4
 335         movups  $inout0,($out)
 336         movups  $inout1,0x10($out)
 337         movups  $inout2,0x20($out)
 338         movups  $inout3,0x30($out)
 339         jmp     .Lecb_ret
 340 .align  16
 341 .Lecb_enc_one:
 342 ___
 343         &aesni_generate1("enc",$key,$rounds);
 344 $code.=<<___;
 345         movups  $inout0,($out)
 346         jmp     .Lecb_ret
 347 .align  16
 348 .Lecb_enc_two:
 349         pxor    $inout2,$inout2
 350         call    _aesni_encrypt3
 351         movups  $inout0,($out)
 352         movups  $inout1,0x10($out)
 353         jmp     .Lecb_ret
 354 .align  16
 355 .Lecb_enc_three:
 356         call    _aesni_encrypt3
 357         movups  $inout0,($out)
 358         movups  $inout1,0x10($out)
 359         movups  $inout2,0x20($out)
 360         jmp     .Lecb_ret
 361 \f#--------------------------- ECB DECRYPT ------------------------------#
 362 .align  16
 363 .Lecb_decrypt:
 364         cmp     \$0x40,$len
 365         jbe     .Lecb_dec_tail
 366         sub     \$0x40,$len
 367         jmp     .Lecb_dec_loop3
 368 .align 16
 369 .Lecb_dec_loop3:
 370         movups  ($inp),$inout0
 371         movups  0x10($inp),$inout1
 372         movups  0x20($inp),$inout2
 373         call    _aesni_decrypt3
 374         lea     0x30($inp),$inp
 375         movups  $inout0,($out)
 376         mov     $rnds_,$rounds          # restore $rounds
 377         movups  $inout1,0x10($out)
 378         mov     $key_,$key              # restore $key
 379         movups  $inout2,0x20($out)
 380         lea     0x30($out),$out
 381         sub     \$0x30,$len
 382         ja      .Lecb_dec_loop3
 383
 384         add     \$0x40,$len
 385 .Lecb_dec_tail:
 386         movups  ($inp),$inout0
 387         cmp     \$0x20,$len
 388         jb      .Lecb_dec_one
 389         movups  0x10($inp),$inout1
 390         je      .Lecb_dec_two
 391         movups  0x20($inp),$inout2
 392         cmp     \$0x30,$len
 393         je      .Lecb_dec_three
 394         movups  0x30($inp),$inout3
 395         call    _aesni_decrypt4
 396         movups  $inout0,($out)
 397         movups  $inout1,0x10($out)
 398         movups  $inout2,0x20($out)
 399         movups  $inout3,0x30($out)
 400         jmp     .Lecb_ret
 401 .align  16
 402 .Lecb_dec_one:
 403 ___
 404         &aesni_generate1("dec",$key,$rounds);
 405 $code.=<<___;
 406         movups  $inout0,($out)
 407         jmp     .Lecb_ret
 408 .align  16
 409 .Lecb_dec_two:
 410         pxor    $inout2,$inout2
 411         call    _aesni_decrypt3
 412         movups  $inout0,($out)
 413         movups  $inout1,0x10($out)
 414         jmp     .Lecb_ret
 415 .align  16
 416 .Lecb_dec_three:
 417         call    _aesni_decrypt3
 418         movups  $inout0,($out)
 419         movups  $inout1,0x10($out)
 420         movups  $inout2,0x20($out)
 421
 422 .Lecb_ret:
 423         ret
 424 .size   aesni_ecb_encrypt,.-aesni_ecb_encrypt
 425 ___
 426 \f
 427 {
 428 ######################################################################
 429 # void aesni_ccm64_[en|de]crypt_blocks (const void *in, void *out,
 430 #                         size_t blocks, const AES_KEY *key,
 431 #                         const char *ivec,char *cmac);
 432 #
 433 # Handles only complete blocks, operates on 64-bit counter and
 434 # does not update *ivec! Nor does it finalize CMAC value
 435 # (see engine/eng_aesni.c for details)
 436 #
 437 {
 438 my $cmac="%r9"; # 6th argument
 439
 440 my $increment="%xmm8";
 441 my $bswap_mask="%xmm9";
 442
 443 $code.=<<___;
 444 .globl  aesni_ccm64_encrypt_blocks
 445 .type   aesni_ccm64_encrypt_blocks,\@function,6
 446 .align  16
 447 aesni_ccm64_encrypt_blocks:
 448 ___
 449 $code.=<<___ if ($win64);
 450         lea     -0x58(%rsp),%rsp
 451         movaps  %xmm6,(%rsp)
 452         movaps  %xmm7,0x10(%rsp)
 453         movaps  %xmm8,0x20(%rsp)
 454         movaps  %xmm9,0x30(%rsp)
 455 .Lccm64_enc_body:
 456 ___
 457 $code.=<<___;
 458         movdqu  ($ivp),$iv
 459         movdqu  ($cmac),$inout1
 460         movdqa  .Lincrement64(%rip),$increment
 461         movdqa  .Lbswap_mask(%rip),$bswap_mask
 462         pshufb  $bswap_mask,$iv                 # keep iv in reverse order
 463
 464         mov     240($key),$rounds               # key->rounds
 465         mov     $key,$key_
 466         mov     $rounds,$rnds_
 467         movdqa  $iv,$inout0
 468
 469 .Lccm64_enc_outer:
 470         movdqu  ($inp),$in0                     # load inp
 471         pshufb  $bswap_mask,$inout0
 472         mov     $key_,$key
 473         mov     $rnds_,$rounds
 474         pxor    $in0,$inout1                    # cmac^=inp
 475         pxor    $inout2,$inout2
 476
 477         call    _aesni_encrypt3
 478
 479         paddq   $increment,$iv
 480         dec     $len
 481         lea     16($inp),$inp
 482         pxor    $inout0,$in0                    # inp ^= E(iv)
 483         movdqa  $iv,$inout0
 484         movdqu  $in0,($out)                     # save output
 485         lea     16($out),$out
 486         jnz     .Lccm64_enc_outer
 487
 488         movdqu  $inout1,($cmac)
 489 ___
 490 $code.=<<___ if ($win64);
 491         movaps  (%rsp),%xmm6
 492         movaps  0x10(%rsp),%xmm7
 493         movaps  0x20(%rsp),%xmm8
 494         movaps  0x30(%rsp),%xmm9
 495         lea     0x58(%rsp),%rsp
 496 .Lccm64_enc_ret:
 497 ___
 498 $code.=<<___;
 499         ret
 500 .size   aesni_ccm64_encrypt_blocks,.-aesni_ccm64_encrypt_blocks
 501 ___
 502 ######################################################################
 503 $code.=<<___;
 504 .globl  aesni_ccm64_decrypt_blocks
 505 .type   aesni_ccm64_decrypt_blocks,\@function,6
 506 .align  16
 507 aesni_ccm64_decrypt_blocks:
 508 ___
 509 $code.=<<___ if ($win64);
 510         lea     -0x58(%rsp),%rsp
 511         movaps  %xmm6,(%rsp)
 512         movaps  %xmm7,0x10(%rsp)
 513         movaps  %xmm8,0x20(%rsp)
 514         movaps  %xmm9,0x30(%rsp)
 515 .Lccm64_dec_body:
 516 ___
 517 $code.=<<___;
 518         movdqu  ($ivp),$iv
 519         movdqu  ($cmac),$inout1
 520         movdqa  .Lincrement64(%rip),$increment
 521         movdqa  .Lbswap_mask(%rip),$bswap_mask
 522
 523         mov     240($key),$rounds               # key->rounds
 524         movdqa  $iv,$inout0
 525         pshufb  $bswap_mask,$iv                 # keep iv in reverse order
 526         mov     $rounds,$rnds_
 527         mov     $key,$key_
 528 ___
 529         &aesni_generate1("enc",$key,$rounds);
 530 $code.=<<___;
 531 .Lccm64_dec_outer:
 532         movdqu  ($inp),$in0                     # load inp
 533         paddq   $increment,$iv
 534         dec     $len
 535         lea     16($inp),$inp
 536         pxor    $inout0,$in0
 537         movdqa  $iv,$inout0
 538         mov     $key_,$key
 539         mov     $rnds_,$rounds
 540         pshufb  $bswap_mask,$inout0
 541         movdqu  $in0,($out)
 542         lea     16($out),$out
 543         pxor    $in0,$inout1                    # cmac^=out
 544
 545         jz      .Lccm64_dec_break
 546
 547         pxor    $inout2,$inout2
 548         call    _aesni_encrypt3
 549
 550         jmp     .Lccm64_dec_outer
 551
 552 .align  16
 553 .Lccm64_dec_break:
 554 ___
 555         &aesni_generate1("enc",$key,$rounds,$inout1);
 556 $code.=<<___;
 557         movdqu  $inout1,($cmac)
 558 ___
 559 $code.=<<___ if ($win64);
 560         movaps  (%rsp),%xmm6
 561         movaps  0x10(%rsp),%xmm7
 562         movaps  0x20(%rsp),%xmm8
 563         movaps  0x30(%rsp),%xmm9
 564         lea     0x58(%rsp),%rsp
 565 .Lccm64_dec_ret:
 566 ___
 567 $code.=<<___;
 568         ret
 569 .size   aesni_ccm64_decrypt_blocks,.-aesni_ccm64_decrypt_blocks
 570 ___
 571 }\f
 572 ######################################################################
 573 # void aesni_ctr32_encrypt_blocks (const void *in, void *out,
 574 #                         size_t blocks, const AES_KEY *key,
 575 #                         const char *ivec);
 576 #
 577 # Handles only complete blocks, operates on 32-bit counter and
 578 # does not update *ivec! (see engine/eng_aesni.c for details)
 579 #
 580 my $increment="%xmm10";
 581 my $bswap_mask="%xmm11";
 582
 583 $code.=<<___;
 584 .globl  aesni_ctr32_encrypt_blocks
 585 .type   aesni_ctr32_encrypt_blocks,\@function,5
 586 .align  16
 587 aesni_ctr32_encrypt_blocks:
 588 ___
 589 $code.=<<___ if ($win64);
 590         lea     -0x68(%rsp),%rsp
 591         movaps  %xmm6,(%rsp)
 592         movaps  %xmm7,0x10(%rsp)
 593         movaps  %xmm8,0x20(%rsp)
 594         movaps  %xmm9,0x30(%rsp)
 595         movaps  %xmm10,0x40(%rsp)
 596         movaps  %xmm11,0x50(%rsp)
 597
 598 .Lctr32_body:
 599 ___
 600 $code.=<<___;
 601         cmp     \$1,$len
 602         je      .Lctr32_one_shortcut
 603
 604         movdqu  ($ivp),$inout3
 605         movdqa  .Lincrement32(%rip),$increment
 606         movdqa  .Lbswap_mask(%rip),$bswap_mask
 607         xor     $rounds,$rounds
 608         pextrd  \$3,$inout3,$rnds_              # pull 32-bit counter
 609         pinsrd  \$3,$rounds,$inout3             # wipe 32-bit counter
 610
 611         mov     240($key),$rounds               # key->rounds
 612         pxor    $iv,$iv                         # vector of 3 32-bit counters
 613         bswap   $rnds_
 614         pinsrd  \$0,$rnds_,$iv
 615         inc     $rnds_
 616         pinsrd  \$1,$rnds_,$iv
 617         inc     $rnds_
 618         pinsrd  \$2,$rnds_,$iv
 619         pshufb  $bswap_mask,$iv
 620
 621         cmp     \$4,$len
 622         jbe     .Lctr32_tail
 623         mov     $rounds,$rnds_
 624         mov     $key,$key_
 625         sub     \$4,$len
 626
 627 .Lctr32_loop3:
 628         pshufd  \$`3<<6`,$iv,$inout0            # place counter to upper dword
 629         pshufd  \$`2<<6`,$iv,$inout1
 630         por     $inout3,$inout0                 # merge counter-less ivec
 631         pshufd  \$`1<<6`,$iv,$inout2
 632         por     $inout3,$inout1
 633         por     $inout3,$inout2
 634
 635         # inline _aesni_encrypt3 and interleave last round
 636         # with own code...
 637
 638         $movkey ($key),$rndkey0
 639         shr     \$1,$rounds
 640         $movkey 16($key),$rndkey1
 641         lea     32($key),$key
 642         pxor    $rndkey0,$inout0
 643         pxor    $rndkey0,$inout1
 644         pxor    $rndkey0,$inout2
 645         $movkey ($key),$rndkey0
 646         jmp     .Lctr32_enc_loop3
 647 .align  16
 648 .Lctr32_enc_loop3:
 649         aesenc          $rndkey1,$inout0
 650         aesenc          $rndkey1,$inout1
 651         dec             $rounds
 652         aesenc          $rndkey1,$inout2
 653         $movkey         16($key),$rndkey1
 654         aesenc          $rndkey0,$inout0
 655         aesenc          $rndkey0,$inout1
 656         lea             32($key),$key
 657         aesenc          $rndkey0,$inout2
 658         $movkey         ($key),$rndkey0
 659         jnz             .Lctr32_enc_loop3
 660
 661         aesenc          $rndkey1,$inout0
 662         aesenc          $rndkey1,$inout1
 663         aesenc          $rndkey1,$inout2
 664
 665         pshufb          $bswap_mask,$iv
 666         movdqu          ($inp),$in0
 667         aesenclast      $rndkey0,$inout0
 668         movdqu          0x10($inp),$in1
 669         paddd           $increment,$iv
 670         aesenclast      $rndkey0,$inout1
 671         movdqu          0x20($inp),$in2
 672         pshufb          $bswap_mask,$iv
 673         aesenclast      $rndkey0,$inout2
 674         lea             0x30($inp),$inp
 675
 676         mov     $key_,$key
 677         pxor    $inout0,$in0
 678         sub     \$3,$len
 679         mov     $rnds_,$rounds
 680         pxor    $inout1,$in1
 681         movdqu  $in0,($out)
 682         pxor    $inout2,$in2
 683         movdqu  $in1,0x10($out)
 684         movdqu  $in2,0x20($out)
 685         lea     0x30($out),$out
 686         ja      .Lctr32_loop3
 687
 688         pextrd  \$1,$iv,$rnds_                  # might need last counter value
 689         add     \$4,$len
 690         bswap   $rnds_
 691
 692 .Lctr32_tail:
 693         pshufd  \$`3<<6`,$iv,$inout0
 694         pshufd  \$`2<<6`,$iv,$inout1
 695         por     $inout3,$inout0
 696         movdqu  ($inp),$in0
 697         cmp     \$2,$len
 698         jb      .Lctr32_one
 699         lea     1($rnds_),$rnds_
 700         pshufd  \$`1<<6`,$iv,$inout2
 701         por     $inout3,$inout1
 702         movdqu  0x10($inp),$in1
 703         je      .Lctr32_two
 704         bswap   $rnds_
 705         por     $inout3,$inout2
 706         movdqu  0x20($inp),$in2
 707         cmp     \$3,$len
 708         je      .Lctr32_three
 709
 710         pinsrd  \$3,$rnds_,$inout3              # compose last counter value
 711         movdqu  0x30($inp),$iv
 712
 713         call    _aesni_encrypt4
 714
 715         pxor    $inout0,$in0
 716         pxor    $inout1,$in1
 717         pxor    $inout2,$in2
 718         movdqu  $in0,($out)
 719         pxor    $inout3,$iv
 720         movdqu  $in1,0x10($out)
 721         movdqu  $in2,0x20($out)
 722         movdqu  $iv,0x30($out)
 723         jmp     .Lctr32_done
 724
 725 .align  16
 726 .Lctr32_one_shortcut:
 727         movdqu  ($ivp),$inout0
 728         movdqu  ($inp),$in0
 729         mov     240($key),$rounds               # key->rounds
 730 .Lctr32_one:
 731 ___
 732         &aesni_generate1("enc",$key,$rounds);
 733 $code.=<<___;
 734         pxor    $inout0,$in0
 735         movdqu  $in0,($out)
 736         jmp     .Lctr32_done
 737
 738 .align  16
 739 .Lctr32_two:
 740         pxor    $inout2,$inout2
 741         call    _aesni_encrypt3
 742         pxor    $inout0,$in0
 743         pxor    $inout1,$in1
 744         movdqu  $in0,($out)
 745         movdqu  $in1,0x10($out)
 746         jmp     .Lctr32_done
 747
 748 .align  16
 749 .Lctr32_three:
 750         call    _aesni_encrypt3
 751         pxor    $inout0,$in0
 752         pxor    $inout1,$in1
 753         pxor    $inout2,$in2
 754         movdqu  $in0,($out)
 755         movdqu  $in1,0x10($out)
 756         movdqu  $in2,0x20($out)
 757
 758 .Lctr32_done:
 759 ___
 760
 761 $code.=<<___ if ($win64);
 762         movaps  (%rsp),%xmm6
 763         movaps  0x10(%rsp),%xmm7
 764         movaps  0x20(%rsp),%xmm8
 765         movaps  0x30(%rsp),%xmm9
 766         movaps  0x40(%rsp),%xmm10
 767         movaps  0x50(%rsp),%xmm11
 768         lea     0x68(%rsp),%rsp
 769 .Lctr32_ret:
 770 ___
 771 $code.=<<___;
 772         ret
 773 .size   aesni_ctr32_encrypt_blocks,.-aesni_ctr32_encrypt_blocks
 774 ___
 775 }}
 776 \f
 777 ########################################################################
 778 # void $PREFIX_cbc_encrypt (const void *inp, void *out,
 779 #                           size_t length, const AES_KEY *key,
 780 #                           unsigned char *ivp,const int enc);
 781 $reserved = $win64?0x40:-0x18;  # used in decrypt
 782 $code.=<<___;
 783 .globl  ${PREFIX}_cbc_encrypt
 784 .type   ${PREFIX}_cbc_encrypt,\@function,6
 785 .align  16
 786 ${PREFIX}_cbc_encrypt:
 787         test    $len,$len               # check length
 788         jz      .Lcbc_ret
 789
 790         mov     240($key),$rnds_        # pull $rounds
 791         mov     $key,$key_              # backup $key
 792         test    %r9d,%r9d               # 6th argument
 793         jz      .Lcbc_decrypt
 794 #--------------------------- CBC ENCRYPT ------------------------------#
 795         movdqu  ($ivp),$inout0          # load iv as initial state
 796         mov     $rnds_,$rounds
 797         cmp     \$16,$len
 798         jb      .Lcbc_enc_tail
 799         sub     \$16,$len
 800         jmp     .Lcbc_enc_loop
 801 .align  16
 802 .Lcbc_enc_loop:
 803         movdqu  ($inp),$inout1          # load input
 804         lea     16($inp),$inp
 805         pxor    $inout1,$inout0
 806 ___
 807         &aesni_generate1("enc",$key,$rounds);
 808 $code.=<<___;
 809         mov     $rnds_,$rounds          # restore $rounds
 810         mov     $key_,$key              # restore $key
 811         movups  $inout0,0($out)         # store output
 812         lea     16($out),$out
 813         sub     \$16,$len
 814         jnc     .Lcbc_enc_loop
 815         add     \$16,$len
 816         jnz     .Lcbc_enc_tail
 817         movups  $inout0,($ivp)
 818         jmp     .Lcbc_ret
 819
 820 .Lcbc_enc_tail:
 821         mov     $len,%rcx       # zaps $key
 822         xchg    $inp,$out       # $inp is %rsi and $out is %rdi now
 823         .long   0x9066A4F3      # rep movsb
 824         mov     \$16,%ecx       # zero tail
 825         sub     $len,%rcx
 826         xor     %eax,%eax
 827         .long   0x9066AAF3      # rep stosb
 828         lea     -16(%rdi),%rdi  # rewind $out by 1 block
 829         mov     $rnds_,$rounds  # restore $rounds
 830         mov     %rdi,%rsi       # $inp and $out are the same
 831         mov     $key_,$key      # restore $key
 832         xor     $len,$len       # len=16
 833         jmp     .Lcbc_enc_loop  # one more spin
 834 \f#--------------------------- CBC DECRYPT ------------------------------#
 835 .align  16
 836 .Lcbc_decrypt:
 837 ___
 838 $code.=<<___ if ($win64);
 839         lea     -0x58(%rsp),%rsp
 840         movaps  %xmm6,(%rsp)
 841         movaps  %xmm7,0x10(%rsp)
 842         movaps  %xmm8,0x20(%rsp)
 843         movaps  %xmm9,0x30(%rsp)
 844 .Lcbc_decrypt_body:
 845 ___
 846 $code.=<<___;
 847         movups  ($ivp),$iv
 848         mov     $rnds_,$rounds
 849         cmp     \$0x40,$len
 850         jbe     .Lcbc_dec_tail
 851         sub     \$0x40,$len
 852         jmp     .Lcbc_dec_loop3
 853 .align  16
 854 .Lcbc_dec_loop3:
 855         movups  ($inp),$inout0
 856         movups  0x10($inp),$inout1
 857         movups  0x20($inp),$inout2
 858         movaps  $inout0,$in0
 859         movaps  $inout1,$in1
 860         movaps  $inout2,$in2
 861
 862         call    _aesni_decrypt3
 863
 864         sub     \$0x30,$len
 865         lea     0x30($inp),$inp
 866         lea     0x30($out),$out
 867         pxor    $iv,$inout0
 868         pxor    $in0,$inout1
 869         movaps  $in2,$iv
 870         pxor    $in1,$inout2
 871         movdqu  $inout0,-0x30($out)
 872         mov     $rnds_,$rounds  # restore $rounds
 873         movdqu  $inout1,-0x20($out)
 874         mov     $key_,$key      # restore $key
 875         movdqu  $inout2,-0x10($out)
 876         ja      .Lcbc_dec_loop3
 877
 878         add     \$0x40,$len
 879         movups  $iv,($ivp)
 880 .Lcbc_dec_tail:
 881         movups  ($inp),$inout0
 882         movaps  $inout0,$in0
 883         cmp     \$0x10,$len
 884         jbe     .Lcbc_dec_one
 885         movups  0x10($inp),$inout1
 886         movaps  $inout1,$in1
 887         cmp     \$0x20,$len
 888         jbe     .Lcbc_dec_two
 889         movups  0x20($inp),$inout2
 890         movaps  $inout2,$in2
 891         cmp     \$0x30,$len
 892         jbe     .Lcbc_dec_three
 893         movups  0x30($inp),$inout3
 894         call    _aesni_decrypt4
 895         pxor    $iv,$inout0
 896         movups  0x30($inp),$iv
 897         pxor    $in0,$inout1
 898         movdqu  $inout0,($out)
 899         pxor    $in1,$inout2
 900         movdqu  $inout1,0x10($out)
 901         pxor    $in2,$inout3
 902         movdqu  $inout2,0x20($out)
 903         movdqa  $inout3,$inout0
 904         lea     0x30($out),$out
 905         jmp     .Lcbc_dec_tail_collected
 906 .align  16
 907 .Lcbc_dec_one:
 908 ___
 909         &aesni_generate1("dec",$key,$rounds);
 910 $code.=<<___;
 911         pxor    $iv,$inout0
 912         movaps  $in0,$iv
 913         jmp     .Lcbc_dec_tail_collected
 914 .align  16
 915 .Lcbc_dec_two:
 916         pxor    $inout2,$inout2
 917         call    _aesni_decrypt3
 918         pxor    $iv,$inout0
 919         pxor    $in0,$inout1
 920         movdqu  $inout0,($out)
 921         movaps  $in1,$iv
 922         movdqa  $inout1,$inout0
 923         lea     0x10($out),$out
 924         jmp     .Lcbc_dec_tail_collected
 925 .align  16
 926 .Lcbc_dec_three:
 927         call    _aesni_decrypt3
 928         pxor    $iv,$inout0
 929         pxor    $in0,$inout1
 930         movdqu  $inout0,($out)
 931         pxor    $in1,$inout2
 932         movdqu  $inout1,0x10($out)
 933         movaps  $in2,$iv
 934         movdqa  $inout2,$inout0
 935         lea     0x20($out),$out
 936         jmp     .Lcbc_dec_tail_collected
 937 .align  16
 938 .Lcbc_dec_tail_collected:
 939         and     \$15,$len
 940         movups  $iv,($ivp)
 941         jnz     .Lcbc_dec_tail_partial
 942         movdqu  $inout0,($out)
 943         jmp     .Lcbc_dec_ret
 944 .align  16
 945 .Lcbc_dec_tail_partial:
 946         movaps  $inout0,$reserved(%rsp)
 947         mov     $out,%rdi
 948         mov     $len,%rcx
 949         lea     $reserved(%rsp),%rsi
 950         .long   0x9066A4F3      # rep movsb
 951
 952 .Lcbc_dec_ret:
 953 ___
 954 $code.=<<___ if ($win64);
 955         movaps  (%rsp),%xmm6
 956         movaps  0x10(%rsp),%xmm7
 957         movaps  0x20(%rsp),%xmm8
 958         movaps  0x30(%rsp),%xmm9
 959         lea     0x58(%rsp),%rsp
 960 ___
 961 $code.=<<___;
 962 .Lcbc_ret:
 963         ret
 964 .size   ${PREFIX}_cbc_encrypt,.-${PREFIX}_cbc_encrypt
 965 ___
 966 \f
 967 # int $PREFIX_set_[en|de]crypt_key (const unsigned char *userKey,
 968 #                               int bits, AES_KEY *key)
 969 { my ($inp,$bits,$key) = @_4args;
 970   $bits =~ s/%r/%e/;
 971
 972 $code.=<<___;
 973 .globl  ${PREFIX}_set_decrypt_key
 974 .type   ${PREFIX}_set_decrypt_key,\@abi-omnipotent
 975 .align  16
 976 ${PREFIX}_set_decrypt_key:
 977         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
 978         call    __aesni_set_encrypt_key
 979         shl     \$4,$bits               # rounds-1 after _aesni_set_encrypt_key
 980         test    %eax,%eax
 981         jnz     .Ldec_key_ret
 982         lea     16($key,$bits),$inp     # points at the end of key schedule
 983
 984         $movkey ($key),%xmm0            # just swap
 985         $movkey ($inp),%xmm1
 986         $movkey %xmm0,($inp)
 987         $movkey %xmm1,($key)
 988         lea     16($key),$key
 989         lea     -16($inp),$inp
 990
 991 .Ldec_key_inverse:
 992         $movkey ($key),%xmm0            # swap and inverse
 993         $movkey ($inp),%xmm1
 994         aesimc  %xmm0,%xmm0
 995         aesimc  %xmm1,%xmm1
 996         lea     16($key),$key
 997         lea     -16($inp),$inp
 998         $movkey %xmm0,16($inp)
 999         $movkey %xmm1,-16($key)
1000         cmp     $key,$inp
1001         ja      .Ldec_key_inverse
1002
1003         $movkey ($key),%xmm0            # inverse middle
1004         aesimc  %xmm0,%xmm0
1005         $movkey %xmm0,($inp)
1006 .Ldec_key_ret:
1007         add     \$8,%rsp
1008         ret
1009 .LSEH_end_set_decrypt_key:
1010 .size   ${PREFIX}_set_decrypt_key,.-${PREFIX}_set_decrypt_key
1011 ___
1012 \f
1013 # This is based on submission by
1014 #
1015 #       Huang Ying <ying.huang@intel.com>
1016 #       Vinodh Gopal <vinodh.gopal@intel.com>
1017 #       Kahraman Akdemir
1018 #
1019 # Agressively optimized in respect to aeskeygenassist's critical path
1020 # and is contained in %xmm0-5 to meet Win64 ABI requirement.
1021 #
1022 $code.=<<___;
1023 .globl  ${PREFIX}_set_encrypt_key
1024 .type   ${PREFIX}_set_encrypt_key,\@abi-omnipotent
1025 .align  16
1026 ${PREFIX}_set_encrypt_key:
1027 __aesni_set_encrypt_key:
1028         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
1029         mov     \$-1,%rax
1030         test    $inp,$inp
1031         jz      .Lenc_key_ret
1032         test    $key,$key
1033         jz      .Lenc_key_ret
1034
1035         movups  ($inp),%xmm0            # pull first 128 bits of *userKey
1036         pxor    %xmm4,%xmm4             # low dword of xmm4 is assumed 0
1037         lea     16($key),%rax
1038         cmp     \$256,$bits
1039         je      .L14rounds
1040         cmp     \$192,$bits
1041         je      .L12rounds
1042         cmp     \$128,$bits
1043         jne     .Lbad_keybits
1044
1045 .L10rounds:
1046         mov     \$9,$bits                       # 10 rounds for 128-bit key
1047         $movkey %xmm0,($key)                    # round 0
1048         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 1
1049         call            .Lkey_expansion_128_cold
1050         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 2
1051         call            .Lkey_expansion_128
1052         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 3
1053         call            .Lkey_expansion_128
1054         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 4
1055         call            .Lkey_expansion_128
1056         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 5
1057         call            .Lkey_expansion_128
1058         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 6
1059         call            .Lkey_expansion_128
1060         aeskeygenassist \$0x40,%xmm0,%xmm1      # round 7
1061         call            .Lkey_expansion_128
1062         aeskeygenassist \$0x80,%xmm0,%xmm1      # round 8
1063         call            .Lkey_expansion_128
1064         aeskeygenassist \$0x1b,%xmm0,%xmm1      # round 9
1065         call            .Lkey_expansion_128
1066         aeskeygenassist \$0x36,%xmm0,%xmm1      # round 10
1067         call            .Lkey_expansion_128
1068         $movkey %xmm0,(%rax)
1069         mov     $bits,80(%rax)  # 240(%rdx)
1070         xor     %eax,%eax
1071         jmp     .Lenc_key_ret
1072
1073 .align  16
1074 .L12rounds:
1075         movq    16($inp),%xmm2                  # remaining 1/3 of *userKey
1076         mov     \$11,$bits                      # 12 rounds for 192
1077         $movkey %xmm0,($key)                    # round 0
1078         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 1,2
1079         call            .Lkey_expansion_192a_cold
1080         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 2,3
1081         call            .Lkey_expansion_192b
1082         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 4,5
1083         call            .Lkey_expansion_192a
1084         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 5,6
1085         call            .Lkey_expansion_192b
1086         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 7,8
1087         call            .Lkey_expansion_192a
1088         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 8,9
1089         call            .Lkey_expansion_192b
1090         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 10,11
1091         call            .Lkey_expansion_192a
1092         aeskeygenassist \$0x80,%xmm2,%xmm1      # round 11,12
1093         call            .Lkey_expansion_192b
1094         $movkey %xmm0,(%rax)
1095         mov     $bits,48(%rax)  # 240(%rdx)
1096         xor     %rax, %rax
1097         jmp     .Lenc_key_ret
1098
1099 .align  16
1100 .L14rounds:
1101         movups  16($inp),%xmm2                  # remaning half of *userKey
1102         mov     \$13,$bits                      # 14 rounds for 256
1103         lea     16(%rax),%rax
1104         $movkey %xmm0,($key)                    # round 0
1105         $movkey %xmm2,16($key)                  # round 1
1106         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 2
1107         call            .Lkey_expansion_256a_cold
1108         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 3
1109         call            .Lkey_expansion_256b
1110         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 4
1111         call            .Lkey_expansion_256a
1112         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 5
1113         call            .Lkey_expansion_256b
1114         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 6
1115         call            .Lkey_expansion_256a
1116         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 7
1117         call            .Lkey_expansion_256b
1118         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 8
1119         call            .Lkey_expansion_256a
1120         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 9
1121         call            .Lkey_expansion_256b
1122         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 10
1123         call            .Lkey_expansion_256a
1124         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 11
1125         call            .Lkey_expansion_256b
1126         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 12
1127         call            .Lkey_expansion_256a
1128         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 13
1129         call            .Lkey_expansion_256b
1130         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 14
1131         call            .Lkey_expansion_256a
1132         $movkey %xmm0,(%rax)
1133         mov     $bits,16(%rax)  # 240(%rdx)
1134         xor     %rax,%rax
1135         jmp     .Lenc_key_ret
1136
1137 .align  16
1138 .Lbad_keybits:
1139         mov     \$-2,%rax
1140 .Lenc_key_ret:
1141         add     \$8,%rsp
1142         ret
1143 .LSEH_end_set_encrypt_key:
1144 \f
1145 .align  16
1146 .Lkey_expansion_128:
1147         $movkey %xmm0,(%rax)
1148         lea     16(%rax),%rax
1149 .Lkey_expansion_128_cold:
1150         shufps  \$0b00010000,%xmm0,%xmm4
1151         pxor    %xmm4, %xmm0
1152         shufps  \$0b10001100,%xmm0,%xmm4
1153         pxor    %xmm4, %xmm0
1154         pshufd  \$0b11111111,%xmm1,%xmm1        # critical path
1155         pxor    %xmm1,%xmm0
1156         ret
1157
1158 .align 16
1159 .Lkey_expansion_192a:
1160         $movkey %xmm0,(%rax)
1161         lea     16(%rax),%rax
1162 .Lkey_expansion_192a_cold:
1163         movaps  %xmm2, %xmm5
1164 .Lkey_expansion_192b_warm:
1165         shufps  \$0b00010000,%xmm0,%xmm4
1166         movaps  %xmm2,%xmm3
1167         pxor    %xmm4,%xmm0
1168         shufps  \$0b10001100,%xmm0,%xmm4
1169         pslldq  \$4,%xmm3
1170         pxor    %xmm4,%xmm0
1171         pshufd  \$0b01010101,%xmm1,%xmm1        # critical path
1172         pxor    %xmm3,%xmm2
1173         pxor    %xmm1,%xmm0
1174         pshufd  \$0b11111111,%xmm0,%xmm3
1175         pxor    %xmm3,%xmm2
1176         ret
1177
1178 .align 16
1179 .Lkey_expansion_192b:
1180         movaps  %xmm0,%xmm3
1181         shufps  \$0b01000100,%xmm0,%xmm5
1182         $movkey %xmm5,(%rax)
1183         shufps  \$0b01001110,%xmm2,%xmm3
1184         $movkey %xmm3,16(%rax)
1185         lea     32(%rax),%rax
1186         jmp     .Lkey_expansion_192b_warm
1187
1188 .align  16
1189 .Lkey_expansion_256a:
1190         $movkey %xmm2,(%rax)
1191         lea     16(%rax),%rax
1192 .Lkey_expansion_256a_cold:
1193         shufps  \$0b00010000,%xmm0,%xmm4
1194         pxor    %xmm4,%xmm0
1195         shufps  \$0b10001100,%xmm0,%xmm4
1196         pxor    %xmm4,%xmm0
1197         pshufd  \$0b11111111,%xmm1,%xmm1        # critical path
1198         pxor    %xmm1,%xmm0
1199         ret
1200
1201 .align 16
1202 .Lkey_expansion_256b:
1203         $movkey %xmm0,(%rax)
1204         lea     16(%rax),%rax
1205
1206         shufps  \$0b00010000,%xmm2,%xmm4
1207         pxor    %xmm4,%xmm2
1208         shufps  \$0b10001100,%xmm2,%xmm4
1209         pxor    %xmm4,%xmm2
1210         pshufd  \$0b10101010,%xmm1,%xmm1        # critical path
1211         pxor    %xmm1,%xmm2
1212         ret
1213 .size   ${PREFIX}_set_encrypt_key,.-${PREFIX}_set_encrypt_key
1214 ___
1215 }
1216 \f
1217 $code.=<<___;
1218 .align  64
1219 .Lbswap_mask:
1220         .byte   15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
1221 .Lincrement32:
1222         .long   3,3,3,0
1223 .Lincrement64:
1224         .long   1,0,0,0
1225 .asciz  "AES for Intel AES-NI, CRYPTOGAMS by <appro\@openssl.org>"
1226 .align  64
1227 ___
1228
1229 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
1230 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
1231 if ($win64) {
1232 $rec="%rcx";
1233 $frame="%rdx";
1234 $context="%r8";
1235 $disp="%r9";
1236
1237 $code.=<<___;
1238 .extern __imp_RtlVirtualUnwind
1239 ___
1240 $code.=<<___ if ($PREFIX eq "aesni");
1241 .type   ecb_se_handler,\@abi-omnipotent
1242 .align  16
1243 ecb_se_handler:
1244         push    %rsi
1245         push    %rdi
1246         push    %rbx
1247         push    %rbp
1248         push    %r12
1249         push    %r13
1250         push    %r14
1251         push    %r15
1252         pushfq
1253         sub     \$64,%rsp
1254
1255         mov     152($context),%rax      # pull context->Rsp
1256         mov     8(%rax),%rdi
1257         mov     16(%rax),%rsi
1258         mov     %rsi,168($context)      # restore context->Rsi
1259         mov     %rdi,176($context)      # restore context->Rdi
1260
1261         jmp     .Lcommon_seh_exit
1262 .size   ecb_se_handler,.-ecb_se_handler
1263
1264 .type   ccm64_se_handler,\@abi-omnipotent
1265 .align  16
1266 ccm64_se_handler:
1267         push    %rsi
1268         push    %rdi
1269         push    %rbx
1270         push    %rbp
1271         push    %r12
1272         push    %r13
1273         push    %r14
1274         push    %r15
1275         pushfq
1276         sub     \$64,%rsp
1277
1278         mov     120($context),%rax      # pull context->Rax
1279         mov     248($context),%rbx      # pull context->Rip
1280
1281         mov     8($disp),%rsi           # disp->ImageBase
1282         mov     56($disp),%r11          # disp->HandlerData
1283
1284         mov     0(%r11),%r10d           # HandlerData[0]
1285         lea     (%rsi,%r10),%r10        # prologue label
1286         cmp     %r10,%rbx               # context->Rip<prologue label
1287         jb      .Lin_ccm64_prologue
1288
1289         mov     152($context),%rax      # pull context->Rsp
1290
1291         mov     4(%r11),%r10d           # HandlerData[1]
1292         lea     (%rsi,%r10),%r10        # epilogue label
1293         cmp     %r10,%rbx               # context->Rip>=epilogue label
1294         jae     .Lin_ccm64_prologue
1295
1296         lea     0(%rax),%rsi            # top of stack
1297         lea     512($context),%rdi      # &context.Xmm6
1298         mov     \$8,%ecx                # 4*sizeof(%xmm0)/sizeof(%rax)
1299         .long   0xa548f3fc              # cld; rep movsq
1300         lea     0x58(%rax),%rax         # adjust stack pointer
1301
1302 .Lin_ccm64_prologue:
1303         mov     8(%rax),%rdi
1304         mov     16(%rax),%rsi
1305         mov     %rax,152($context)      # restore context->Rsp
1306         mov     %rsi,168($context)      # restore context->Rsi
1307         mov     %rdi,176($context)      # restore context->Rdi
1308
1309         jmp     .Lcommon_seh_exit
1310 .size   ccm64_se_handler,.-ccm64_se_handler
1311
1312 .type   ctr32_se_handler,\@abi-omnipotent
1313 .align  16
1314 ctr32_se_handler:
1315         push    %rsi
1316         push    %rdi
1317         push    %rbx
1318         push    %rbp
1319         push    %r12
1320         push    %r13
1321         push    %r14
1322         push    %r15
1323         pushfq
1324         sub     \$64,%rsp
1325
1326         mov     120($context),%rax      # pull context->Rax
1327         mov     248($context),%rbx      # pull context->Rip
1328
1329         lea     .Lctr32_body(%rip),%r10
1330         cmp     %r10,%rbx               # context->Rip<"prologue" label
1331         jb      .Lin_ctr32_prologue
1332
1333         mov     152($context),%rax      # pull context->Rsp
1334
1335         lea     .Lctr32_ret(%rip),%r10
1336         cmp     %r10,%rbx
1337         jae     .Lin_ctr32_prologue
1338
1339         lea     0(%rax),%rsi            # top of stack
1340         lea     512($context),%rdi      # &context.Xmm6
1341         mov     \$12,%ecx               # 6*sizeof(%xmm0)/sizeof(%rax)
1342         .long   0xa548f3fc              # cld; rep movsq
1343         lea     0x68(%rax),%rax         # adjust stack pointer
1344
1345 .Lin_ctr32_prologue:
1346         mov     8(%rax),%rdi
1347         mov     16(%rax),%rsi
1348         mov     %rax,152($context)      # restore context->Rsp
1349         mov     %rsi,168($context)      # restore context->Rsi
1350         mov     %rdi,176($context)      # restore context->Rdi
1351
1352         jmp     .Lcommon_seh_exit
1353 .size   ctr32_se_handler,.-ctr32_se_handler
1354 ___
1355 $code.=<<___;
1356 .type   cbc_se_handler,\@abi-omnipotent
1357 .align  16
1358 cbc_se_handler:
1359         push    %rsi
1360         push    %rdi
1361         push    %rbx
1362         push    %rbp
1363         push    %r12
1364         push    %r13
1365         push    %r14
1366         push    %r15
1367         pushfq
1368         sub     \$64,%rsp
1369
1370         mov     152($context),%rax      # pull context->Rsp
1371         mov     248($context),%rbx      # pull context->Rip
1372
1373         lea     .Lcbc_decrypt(%rip),%r10
1374         cmp     %r10,%rbx               # context->Rip<"prologue" label
1375         jb      .Lin_cbc_prologue
1376
1377         lea     .Lcbc_decrypt_body(%rip),%r10
1378         cmp     %r10,%rbx               # context->Rip<cbc_decrypt_body
1379         jb      .Lrestore_cbc_rax
1380
1381         lea     .Lcbc_ret(%rip),%r10
1382         cmp     %r10,%rbx               # context->Rip>="epilogue" label
1383         jae     .Lin_cbc_prologue
1384
1385         lea     0(%rax),%rsi            # top of stack
1386         lea     512($context),%rdi      # &context.Xmm6
1387         mov     \$8,%ecx                # 4*sizeof(%xmm0)/sizeof(%rax)
1388         .long   0xa548f3fc              # cld; rep movsq
1389         lea     0x58(%rax),%rax         # adjust stack pointer
1390         jmp     .Lin_cbc_prologue
1391
1392 .Lrestore_cbc_rax:
1393         mov     120($context),%rax
1394 .Lin_cbc_prologue:
1395         mov     8(%rax),%rdi
1396         mov     16(%rax),%rsi
1397         mov     %rax,152($context)      # restore context->Rsp
1398         mov     %rsi,168($context)      # restore context->Rsi
1399         mov     %rdi,176($context)      # restore context->Rdi
1400
1401 .Lcommon_seh_exit:
1402
1403         mov     40($disp),%rdi          # disp->ContextRecord
1404         mov     $context,%rsi           # context
1405         mov     \$154,%ecx              # sizeof(CONTEXT)
1406         .long   0xa548f3fc              # cld; rep movsq
1407
1408         mov     $disp,%rsi
1409         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
1410         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
1411         mov     0(%rsi),%r8             # arg3, disp->ControlPc
1412         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
1413         mov     40(%rsi),%r10           # disp->ContextRecord
1414         lea     56(%rsi),%r11           # &disp->HandlerData
1415         lea     24(%rsi),%r12           # &disp->EstablisherFrame
1416         mov     %r10,32(%rsp)           # arg5
1417         mov     %r11,40(%rsp)           # arg6
1418         mov     %r12,48(%rsp)           # arg7
1419         mov     %rcx,56(%rsp)           # arg8, (NULL)
1420         call    *__imp_RtlVirtualUnwind(%rip)
1421
1422         mov     \$1,%eax                # ExceptionContinueSearch
1423         add     \$64,%rsp
1424         popfq
1425         pop     %r15
1426         pop     %r14
1427         pop     %r13
1428         pop     %r12
1429         pop     %rbp
1430         pop     %rbx
1431         pop     %rdi
1432         pop     %rsi
1433         ret
1434 .size   cbc_se_handler,.-cbc_se_handler
1435
1436 .section        .pdata
1437 .align  4
1438 ___
1439 $code.=<<___ if ($PREFIX eq "aesni");
1440         .rva    .LSEH_begin_aesni_ecb_encrypt
1441         .rva    .LSEH_end_aesni_ecb_encrypt
1442         .rva    .LSEH_info_ecb
1443
1444         .rva    .LSEH_begin_aesni_ccm64_encrypt_blocks
1445         .rva    .LSEH_end_aesni_ccm64_encrypt_blocks
1446         .rva    .LSEH_info_ccm64_enc
1447
1448         .rva    .LSEH_begin_aesni_ccm64_decrypt_blocks
1449         .rva    .LSEH_end_aesni_ccm64_decrypt_blocks
1450         .rva    .LSEH_info_ccm64_dec
1451
1452         .rva    .LSEH_begin_aesni_ctr32_encrypt_blocks
1453         .rva    .LSEH_end_aesni_ctr32_encrypt_blocks
1454         .rva    .LSEH_info_ctr32
1455 ___
1456 $code.=<<___;
1457         .rva    .LSEH_begin_${PREFIX}_cbc_encrypt
1458         .rva    .LSEH_end_${PREFIX}_cbc_encrypt
1459         .rva    .LSEH_info_cbc
1460
1461         .rva    ${PREFIX}_set_decrypt_key
1462         .rva    .LSEH_end_set_decrypt_key
1463         .rva    .LSEH_info_key
1464
1465         .rva    ${PREFIX}_set_encrypt_key
1466         .rva    .LSEH_end_set_encrypt_key
1467         .rva    .LSEH_info_key
1468 .section        .xdata
1469 .align  8
1470 ___
1471 $code.=<<___ if ($PREFIX eq "aesni");
1472 .LSEH_info_ecb:
1473         .byte   9,0,0,0
1474         .rva    ecb_se_handler
1475 .LSEH_info_ccm64_enc:
1476         .byte   9,0,0,0
1477         .rva    ccm64_se_handler
1478         .rva    .Lccm64_enc_body,.Lccm64_enc_ret        # HandlerData[]
1479 .LSEH_info_ccm64_dec:
1480         .byte   9,0,0,0
1481         .rva    ccm64_se_handler
1482         .rva    .Lccm64_dec_body,.Lccm64_dec_ret        # HandlerData[]
1483 .LSEH_info_ctr32:
1484         .byte   9,0,0,0
1485         .rva    ctr32_se_handler
1486 ___
1487 $code.=<<___;
1488 .LSEH_info_cbc:
1489         .byte   9,0,0,0
1490         .rva    cbc_se_handler
1491 .LSEH_info_key:
1492         .byte   0x01,0x04,0x01,0x00
1493         .byte   0x04,0x02,0x00,0x00     # sub rsp,8
1494 ___
1495 }
1496
1497 sub rex {
1498  local *opcode=shift;
1499  my ($dst,$src)=@_;
1500
1501    if ($dst>=8 || $src>=8) {
1502         $rex=0x40;
1503         $rex|=0x04 if($dst>=8);
1504         $rex|=0x01 if($src>=8);
1505         push @opcode,$rex;
1506    }
1507 }
1508
1509 sub aesni {
1510   my $line=shift;
1511   my @opcode=(0x66);
1512
1513     if ($line=~/(aeskeygenassist)\s+\$([x0-9a-f]+),\s*%xmm([0-9]+),\s*%xmm([0-9]+)/) {
1514         rex(\@opcode,$4,$3);
1515         push @opcode,0x0f,0x3a,0xdf;
1516         push @opcode,0xc0|($3&7)|(($4&7)<<3);   # ModR/M
1517         my $c=$2;
1518         push @opcode,$c=~/^0/?oct($c):$c;
1519         return ".byte\t".join(',',@opcode);
1520     }
1521     elsif ($line=~/(aes[a-z]+)\s+%xmm([0-9]+),\s*%xmm([0-9]+)/) {
1522         my %opcodelet = (
1523                 "aesimc" => 0xdb,
1524                 "aesenc" => 0xdc,       "aesenclast" => 0xdd,
1525                 "aesdec" => 0xde,       "aesdeclast" => 0xdf
1526         );
1527         return undef if (!defined($opcodelet{$1}));
1528         rex(\@opcode,$3,$2);
1529         push @opcode,0x0f,0x38,$opcodelet{$1};
1530         push @opcode,0xc0|($2&7)|(($3&7)<<3);   # ModR/M
1531         return ".byte\t".join(',',@opcode);
1532     }
1533     return $line;
1534 }
1535
1536 $code =~ s/\`([^\`]*)\`/eval($1)/gem;
1537 $code =~ s/\b(aes.*%xmm[0-9]+).*$/aesni($1)/gem;
1538
1539 print $code;
1540
1541 close STDOUT;