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 $PREFIX="aesni";        # if $PREFIX is set to "AES", the script
  16                         # generates drop-in replacement for
  17                         # crypto/aes/asm/aes-x86_64.pl:-)
  18
  19 $flavour = shift;
  20 $output  = shift;
  21 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
  22
  23 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
  24
  25 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  26 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
  27 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
  28 die "can't locate x86_64-xlate.pl";
  29
  30 open STDOUT,"| $^X $xlate $flavour $output";
  31
  32 $movkey = $PREFIX eq "aesni" ? "movaps" : "movups";
  33 @_4args=$win64? ("%rcx","%rdx","%r8", "%r9") :  # Win64 order
  34                 ("%rdi","%rsi","%rdx","%rcx");  # Unix order
  35
  36 $code=".text\n";
  37
  38 $rounds="%eax"; # input to and changed by aesni_[en|de]cryptN !!!
  39 # this is natural Unix argument order for public $PREFIX_[ecb|cbc]_encrypt ...
  40 $inp="%rdi";
  41 $out="%rsi";
  42 $len="%rdx";
  43 $key="%rcx";    # input to and changed by aesni_[en|de]cryptN !!!
  44 $ivp="%r8";     # cbc, ctr
  45
  46 $rnds_="%r10d"; # backup copy for $rounds
  47 $key_="%r11";   # backup copy for $key
  48
  49 # %xmm register layout
  50 $inout0="%xmm0";        $inout1="%xmm1";
  51 $inout2="%xmm2";        $inout3="%xmm3";
  52 $rndkey0="%xmm4";       $rndkey1="%xmm5";
  53
  54 $iv="%xmm6";            $in0="%xmm7";   # used in CBC decrypt, CTR
  55 $in1="%xmm8";           $in2="%xmm9";
  56 \f
  57 # Inline version of internal aesni_[en|de]crypt1.
  58 #
  59 # Why folded loop? Because aes[enc|dec] is slow enough to accommodate
  60 # cycles which take care of loop variables...
  61 { my $sn;
  62 sub aesni_generate1 {
  63 my ($p,$key,$rounds)=@_;
  64 ++$sn;
  65 $code.=<<___;
  66         $movkey ($key),$rndkey0
  67         $movkey 16($key),$rndkey1
  68         lea     32($key),$key
  69         pxor    $rndkey0,$inout0
  70 .Loop_${p}1_$sn:
  71         aes${p} $rndkey1,$inout0
  72         dec     $rounds
  73         $movkey ($key),$rndkey1
  74         lea     16($key),$key
  75         jnz     .Loop_${p}1_$sn # loop body is 16 bytes
  76         aes${p}last     $rndkey1,$inout0
  77 ___
  78 }}
  79 # void $PREFIX_[en|de]crypt (const void *inp,void *out,const AES_KEY *key);
  80 #
  81 { my ($inp,$out,$key) = @_4args;
  82
  83 $code.=<<___;
  84 .globl  ${PREFIX}_encrypt
  85 .type   ${PREFIX}_encrypt,\@abi-omnipotent
  86 .align  16
  87 ${PREFIX}_encrypt:
  88         movups  ($inp),$inout0          # load input
  89         mov     240($key),$rounds       # pull $rounds
  90 ___
  91         &aesni_generate1("enc",$key,$rounds);
  92 $code.=<<___;
  93         movups  $inout0,($out)          # output
  94         ret
  95 .size   ${PREFIX}_encrypt,.-${PREFIX}_encrypt
  96
  97 .globl  ${PREFIX}_decrypt
  98 .type   ${PREFIX}_decrypt,\@abi-omnipotent
  99 .align  16
 100 ${PREFIX}_decrypt:
 101         movups  ($inp),$inout0          # load input
 102         mov     240($key),$rounds       # pull $rounds
 103 ___
 104         &aesni_generate1("dec",$key,$rounds);
 105 $code.=<<___;
 106         movups  $inout0,($out)          # output
 107         ret
 108 .size   ${PREFIX}_decrypt, .-${PREFIX}_decrypt
 109 ___
 110 }
 111 \f
 112 # _aesni_[en|de]crypt[34] are private interfaces, N denotes interleave
 113 # factor. Why 3x subroutine is used in loops? Even though aes[enc|dec]
 114 # latency is 6, it turned out that it can be scheduled only every
 115 # *second* cycle. Thus 3x interleave is the one providing optimal
 116 # utilization, i.e. when subroutine's throughput is virtually same as
 117 # of non-interleaved subroutine [for number of input blocks up to 3].
 118 # This is why it makes no sense to implement 2x subroutine. As soon
 119 # as/if Intel improves throughput by making it possible to schedule
 120 # the instructions in question *every* cycles I would have to
 121 # implement 6x interleave and use it in loop...
 122 sub aesni_generate3 {
 123 my $dir=shift;
 124 # As already mentioned it takes in $key and $rounds, which are *not*
 125 # preserved. $inout[0-2] is cipher/clear text...
 126 $code.=<<___;
 127 .type   _aesni_${dir}rypt3,\@abi-omnipotent
 128 .align  16
 129 _aesni_${dir}rypt3:
 130         $movkey ($key),$rndkey0
 131         shr     \$1,$rounds
 132         $movkey 16($key),$rndkey1
 133         lea     32($key),$key
 134         pxor    $rndkey0,$inout0
 135         pxor    $rndkey0,$inout1
 136         pxor    $rndkey0,$inout2
 137
 138 .L${dir}_loop3:
 139         aes${dir}       $rndkey1,$inout0
 140         $movkey         ($key),$rndkey0
 141         aes${dir}       $rndkey1,$inout1
 142         dec             $rounds
 143         aes${dir}       $rndkey1,$inout2
 144         aes${dir}       $rndkey0,$inout0
 145         $movkey         16($key),$rndkey1
 146         aes${dir}       $rndkey0,$inout1
 147         lea             32($key),$key
 148         aes${dir}       $rndkey0,$inout2
 149         jnz             .L${dir}_loop3
 150
 151         aes${dir}       $rndkey1,$inout0
 152         $movkey         ($key),$rndkey0
 153         aes${dir}       $rndkey1,$inout1
 154         aes${dir}       $rndkey1,$inout2
 155         aes${dir}last   $rndkey0,$inout0
 156         aes${dir}last   $rndkey0,$inout1
 157         aes${dir}last   $rndkey0,$inout2
 158         ret
 159 .size   _aesni_${dir}rypt3,.-_aesni_${dir}rypt3
 160 ___
 161 }
 162 # 4x interleave is implemented to improve small block performance,
 163 # most notably [and naturally] 4 block by ~30%. One can argue that one
 164 # should have implemented 5x as well, but improvement would be <20%,
 165 # so it's not worth it...
 166 sub aesni_generate4 {
 167 my $dir=shift;
 168 # As already mentioned it takes in $key and $rounds, which are *not*
 169 # preserved. $inout[0-3] is cipher/clear text...
 170 $code.=<<___;
 171 .type   _aesni_${dir}rypt4,\@abi-omnipotent
 172 .align  16
 173 _aesni_${dir}rypt4:
 174         $movkey ($key),$rndkey0
 175         shr     \$1,$rounds
 176         $movkey 16($key),$rndkey1
 177         lea     32($key),$key
 178         pxor    $rndkey0,$inout0
 179         pxor    $rndkey0,$inout1
 180         pxor    $rndkey0,$inout2
 181         pxor    $rndkey0,$inout3
 182
 183 .L${dir}_loop4:
 184         aes${dir}       $rndkey1,$inout0
 185         $movkey         ($key),$rndkey0
 186         aes${dir}       $rndkey1,$inout1
 187         dec             $rounds
 188         aes${dir}       $rndkey1,$inout2
 189         aes${dir}       $rndkey1,$inout3
 190         aes${dir}       $rndkey0,$inout0
 191         $movkey         16($key),$rndkey1
 192         aes${dir}       $rndkey0,$inout1
 193         lea             32($key),$key
 194         aes${dir}       $rndkey0,$inout2
 195         aes${dir}       $rndkey0,$inout3
 196         jnz             .L${dir}_loop4
 197
 198         aes${dir}       $rndkey1,$inout0
 199         $movkey         ($key),$rndkey0
 200         aes${dir}       $rndkey1,$inout1
 201         aes${dir}       $rndkey1,$inout2
 202         aes${dir}       $rndkey1,$inout3
 203         aes${dir}last   $rndkey0,$inout0
 204         aes${dir}last   $rndkey0,$inout1
 205         aes${dir}last   $rndkey0,$inout2
 206         aes${dir}last   $rndkey0,$inout3
 207         ret
 208 .size   _aesni_${dir}rypt4,.-_aesni_${dir}rypt4
 209 ___
 210 }
 211 &aesni_generate3("enc") if ($PREFIX eq "aesni");
 212 &aesni_generate3("dec");
 213 &aesni_generate4("enc") if ($PREFIX eq "aesni");
 214 &aesni_generate4("dec");
 215 \f
 216 if ($PREFIX eq "aesni") {
 217 ########################################################################
 218 # void aesni_ecb_encrypt (const void *in, void *out,
 219 #                         size_t length, const AES_KEY *key,
 220 #                         int enc);
 221 $code.=<<___;
 222 .globl  aesni_ecb_encrypt
 223 .type   aesni_ecb_encrypt,\@function,5
 224 .align  16
 225 aesni_ecb_encrypt:
 226         cmp     \$16,$len               # check length
 227         jb      .Lecb_ret
 228
 229         mov     240($key),$rounds       # pull $rounds
 230         and     \$-16,$len
 231         mov     $key,$key_              # backup $key
 232         test    %r8d,%r8d               # 5th argument
 233         mov     $rounds,$rnds_          # backup $rounds
 234         jz      .Lecb_decrypt
 235 #--------------------------- ECB ENCRYPT ------------------------------#
 236         cmp     \$0x40,$len
 237         jbe     .Lecb_enc_tail
 238         sub     \$0x40,$len
 239         jmp     .Lecb_enc_loop3
 240 .align 16
 241 .Lecb_enc_loop3:
 242         movups  ($inp),$inout0
 243         movups  0x10($inp),$inout1
 244         movups  0x20($inp),$inout2
 245         call    _aesni_encrypt3
 246         sub     \$0x30,$len
 247         lea     0x30($inp),$inp
 248         lea     0x30($out),$out
 249         movups  $inout0,-0x30($out)
 250         mov     $rnds_,$rounds          # restore $rounds
 251         movups  $inout1,-0x20($out)
 252         mov     $key_,$key              # restore $key
 253         movups  $inout2,-0x10($out)
 254         ja      .Lecb_enc_loop3
 255
 256         add     \$0x40,$len
 257         jz      .Lecb_ret
 258
 259 .Lecb_enc_tail:
 260         cmp     \$0x20,$len
 261         movups  ($inp),$inout0
 262         jb      .Lecb_enc_one
 263         movups  0x10($inp),$inout1
 264         je      .Lecb_enc_two
 265         cmp     \$0x30,$len
 266         movups  0x20($inp),$inout2
 267         je      .Lecb_enc_three
 268         movups  0x30($inp),$inout3
 269         call    _aesni_encrypt4
 270         movups  $inout0,($out)
 271         movups  $inout1,0x10($out)
 272         movups  $inout2,0x20($out)
 273         movups  $inout3,0x30($out)
 274         jmp     .Lecb_ret
 275 .align  16
 276 .Lecb_enc_one:
 277 ___
 278         &aesni_generate1("enc",$key,$rounds);
 279 $code.=<<___;
 280         movups  $inout0,($out)
 281         jmp     .Lecb_ret
 282 .align  16
 283 .Lecb_enc_two:
 284         call    _aesni_encrypt3
 285         movups  $inout0,($out)
 286         movups  $inout1,0x10($out)
 287         jmp     .Lecb_ret
 288 .align  16
 289 .Lecb_enc_three:
 290         call    _aesni_encrypt3
 291         movups  $inout0,($out)
 292         movups  $inout1,0x10($out)
 293         movups  $inout2,0x20($out)
 294         jmp     .Lecb_ret
 295 \f#--------------------------- ECB DECRYPT ------------------------------#
 296 .align  16
 297 .Lecb_decrypt:
 298         cmp     \$0x40,$len
 299         jbe     .Lecb_dec_tail
 300         sub     \$0x40,$len
 301         jmp     .Lecb_dec_loop3
 302 .align 16
 303 .Lecb_dec_loop3:
 304         movups  ($inp),$inout0
 305         movups  0x10($inp),$inout1
 306         movups  0x20($inp),$inout2
 307         call    _aesni_decrypt3
 308         sub     \$0x30,$len
 309         lea     0x30($inp),$inp
 310         lea     0x30($out),$out
 311         movups  $inout0,-0x30($out)
 312         mov     $rnds_,$rounds          # restore $rounds
 313         movups  $inout1,-0x20($out)
 314         mov     $key_,$key              # restore $key
 315         movups  $inout2,-0x10($out)
 316         ja      .Lecb_dec_loop3
 317
 318         add     \$0x40,$len
 319         jz      .Lecb_ret
 320
 321 .Lecb_dec_tail:
 322         cmp     \$0x20,$len
 323         movups  ($inp),$inout0
 324         jb      .Lecb_dec_one
 325         movups  0x10($inp),$inout1
 326         je      .Lecb_dec_two
 327         cmp     \$0x30,$len
 328         movups  0x20($inp),$inout2
 329         je      .Lecb_dec_three
 330         movups  0x30($inp),$inout3
 331         call    _aesni_decrypt4
 332         movups  $inout0,($out)
 333         movups  $inout1,0x10($out)
 334         movups  $inout2,0x20($out)
 335         movups  $inout3,0x30($out)
 336         jmp     .Lecb_ret
 337 .align  16
 338 .Lecb_dec_one:
 339 ___
 340         &aesni_generate1("dec",$key,$rounds);
 341 $code.=<<___;
 342         movups  $inout0,($out)
 343         jmp     .Lecb_ret
 344 .align  16
 345 .Lecb_dec_two:
 346         call    _aesni_decrypt3
 347         movups  $inout0,($out)
 348         movups  $inout1,0x10($out)
 349         jmp     .Lecb_ret
 350 .align  16
 351 .Lecb_dec_three:
 352         call    _aesni_decrypt3
 353         movups  $inout0,($out)
 354         movups  $inout1,0x10($out)
 355         movups  $inout2,0x20($out)
 356
 357 .Lecb_ret:
 358         ret
 359 .size   aesni_ecb_encrypt,.-aesni_ecb_encrypt
 360 ___
 361 ######################################################################
 362 # handles only complete blocks, operates on 32-bit counter and
 363 # does not update *ivec! (see engine/eng_aesni.c for details)
 364 #
 365 # void aesni_ctr32_encrypt_blocks (const void *in, void *out,
 366 #                         size_t blocks, const AES_KEY *key,
 367 #                         const char *ivec);
 368 $increment="%xmm10";
 369 $bswap_mask="%xmm11";
 370
 371 $code.=<<___;
 372 .globl  aesni_ctr32_encrypt_blocks
 373 .type   aesni_ctr32_encrypt_blocks,\@function,5
 374 .align  16
 375 aesni_ctr32_encrypt_blocks:
 376 ___
 377 $code.=<<___ if ($win64);
 378         lea     -0x68(%rsp),%rsp
 379         movaps  %xmm6,(%rsp)
 380         movaps  %xmm7,0x10(%rsp)
 381         movaps  %xmm8,0x20(%rsp)
 382         movaps  %xmm9,0x30(%rsp)
 383         movaps  %xmm10,0x40(%rsp)
 384         movaps  %xmm11,0x50(%rsp)
 385
 386 .Lctr32_body:
 387 ___
 388 $code.=<<___;
 389         movups  ($ivp),$inout3
 390         movaps  .Lincrement(%rip),$increment
 391         movaps  .Lbswap_mask(%rip),$bswap_mask
 392         xor     $rounds,$rounds
 393         pextrd  \$3,$inout3,$rnds_              # pull 32-bit counter
 394         pinsrd  \$3,$rounds,$inout3             # wipe 32-bit counter
 395
 396         mov     240($key),$rounds               # key->rounds
 397         pxor    $iv,$iv                         # vector of 3 32-bit counters
 398         bswap   $rnds_
 399         pinsrd  \$0,$rnds_,$iv
 400         inc     $rnds_
 401         pinsrd  \$1,$rnds_,$iv
 402         inc     $rnds_
 403         pinsrd  \$2,$rnds_,$iv
 404
 405         cmp     \$4,$len
 406         pshufb  $bswap_mask,$iv
 407         jbe     .Lctr32_tail
 408         mov     $rounds,$rnds_
 409         mov     $key,$key_
 410         sub     \$4,$len
 411         jmp     .Lctr32_loop3
 412
 413 .align  16
 414 .Lctr32_loop3:
 415         pshufd  \$`3<<6`,$iv,$inout0            # place counter to upper dword
 416         pshufd  \$`2<<6`,$iv,$inout1
 417         pshufd  \$`1<<6`,$iv,$inout2
 418         movups  ($inp),$in0
 419         movups  0x10($inp),$in1
 420         movups  0x20($inp),$in2
 421         por     $inout3,$inout0                 # merge counter-less ivec
 422         por     $inout3,$inout1
 423         por     $inout3,$inout2
 424         pshufb  $bswap_mask,$iv
 425
 426         call    _aesni_encrypt3
 427
 428         paddd   $increment,$iv
 429         pxor    $inout0,$in0
 430         pxor    $inout1,$in1
 431         pxor    $inout2,$in2
 432         pshufb  $bswap_mask,$iv
 433         movups  $in0,($out)
 434         movups  $in1,0x10($out)
 435         movups  $in2,0x20($out)
 436
 437         sub     \$3,$len
 438         lea     0x30($inp),$inp
 439         lea     0x30($out),$out
 440         mov     $key_,$key
 441         mov     $rnds_,$rounds
 442         ja      .Lctr32_loop3
 443
 444         add     \$4,$len
 445         pextrd  \$1,$iv,$rnds_                  # migh need last counter value
 446         jz      .Lctr32_done
 447         bswap   $rnds_
 448
 449 .Lctr32_tail:
 450         cmp     \$2,$len
 451         pshufd  \$`3<<6`,$iv,$inout0
 452         pshufd  \$`2<<6`,$iv,$inout1
 453         pshufd  \$`1<<6`,$iv,$inout2
 454         por     $inout3,$inout0
 455         movups  ($inp),$in0
 456         jb      .Lctr32_one
 457         por     $inout3,$inout1
 458         movups  0x10($inp),$in1
 459         je      .Lctr32_two
 460         cmp     \$3,$len
 461         por     $inout3,$inout2
 462         movups  0x20($inp),$in2
 463         je      .Lctr32_three
 464
 465         inc     $rnds_                          # compose last counter value
 466         bswap   $rnds_
 467         pinsrd  \$3,$rnds_,$inout3
 468         movups  0x30($inp),$iv
 469
 470         call    _aesni_encrypt4
 471
 472         pxor    $inout0,$in0
 473         pxor    $inout1,$in1
 474         pxor    $inout2,$in2
 475         pxor    $inout3,$iv
 476         movups  $in0,($out)
 477         movups  $in1,0x10($out)
 478         movups  $in2,0x20($out)
 479         movups  $iv,0x30($out)
 480         jmp     .Lctr32_done
 481
 482 .align  16
 483 .Lctr32_one:
 484 ___
 485         &aesni_generate1("enc",$key,$rounds);
 486 $code.=<<___;
 487         pxor    $inout0,$in0
 488         movups  $in0,($out)
 489         jmp     .Lctr32_done
 490
 491 .align  16
 492 .Lctr32_two:
 493         call    _aesni_encrypt3
 494         pxor    $inout0,$in0
 495         pxor    $inout1,$in1
 496         movups  $in0,($out)
 497         movups  $in1,0x10($out)
 498         jmp     .Lctr32_done
 499
 500 .align  16
 501 .Lctr32_three:
 502         call    _aesni_encrypt3
 503         pxor    $inout0,$in0
 504         pxor    $inout1,$in1
 505         pxor    $inout2,$in2
 506         movups  $in0,($out)
 507         movups  $in1,0x10($out)
 508         movups  $in2,0x20($out)
 509
 510 .Lctr32_done:
 511 ___
 512
 513 $code.=<<___ if ($win64);
 514         movaps  (%rsp),%xmm6
 515         movaps  0x10(%rsp),%xmm7
 516         movaps  0x20(%rsp),%xmm8
 517         movaps  0x30(%rsp),%xmm9
 518         movaps  0x40(%rsp),%xmm10
 519         movaps  0x50(%rsp),%xmm11
 520         lea     0x68(%rsp),%rsp
 521 ___
 522 $code.=<<___;
 523 .Lctr32_ret:
 524         ret
 525 .size   aesni_ctr32_encrypt_blocks,.-aesni_ctr32_encrypt_blocks
 526 ___
 527 }
 528 \f
 529 ########################################################################
 530 # void $PREFIX_cbc_encrypt (const void *inp, void *out,
 531 #                           size_t length, const AES_KEY *key,
 532 #                           unsigned char *ivp,const int enc);
 533 $reserved = $win64?0x40:-0x18;  # used in decrypt
 534 $code.=<<___;
 535 .globl  ${PREFIX}_cbc_encrypt
 536 .type   ${PREFIX}_cbc_encrypt,\@function,6
 537 .align  16
 538 ${PREFIX}_cbc_encrypt:
 539         test    $len,$len               # check length
 540         jz      .Lcbc_ret
 541
 542         mov     240($key),$rnds_        # pull $rounds
 543         mov     $key,$key_              # backup $key
 544         test    %r9d,%r9d               # 6th argument
 545         jz      .Lcbc_decrypt
 546 #--------------------------- CBC ENCRYPT ------------------------------#
 547         movups  ($ivp),$inout0          # load iv as initial state
 548         cmp     \$16,$len
 549         mov     $rnds_,$rounds
 550         jb      .Lcbc_enc_tail
 551         sub     \$16,$len
 552         jmp     .Lcbc_enc_loop
 553 .align 16
 554 .Lcbc_enc_loop:
 555         movups  ($inp),$inout1          # load input
 556         lea     16($inp),$inp
 557         pxor    $inout1,$inout0
 558 ___
 559         &aesni_generate1("enc",$key,$rounds);
 560 $code.=<<___;
 561         sub     \$16,$len
 562         lea     16($out),$out
 563         mov     $rnds_,$rounds          # restore $rounds
 564         mov     $key_,$key              # restore $key
 565         movups  $inout0,-16($out)       # store output
 566         jnc     .Lcbc_enc_loop
 567         add     \$16,$len
 568         jnz     .Lcbc_enc_tail
 569         movups  $inout0,($ivp)
 570         jmp     .Lcbc_ret
 571
 572 .Lcbc_enc_tail:
 573         mov     $len,%rcx       # zaps $key
 574         xchg    $inp,$out       # $inp is %rsi and $out is %rdi now
 575         .long   0x9066A4F3      # rep movsb
 576         mov     \$16,%ecx       # zero tail
 577         sub     $len,%rcx
 578         xor     %eax,%eax
 579         .long   0x9066AAF3      # rep stosb
 580         lea     -16(%rdi),%rdi  # rewind $out by 1 block
 581         mov     $rnds_,$rounds  # restore $rounds
 582         mov     %rdi,%rsi       # $inp and $out are the same
 583         mov     $key_,$key      # restore $key
 584         xor     $len,$len       # len=16
 585         jmp     .Lcbc_enc_loop  # one more spin
 586 \f#--------------------------- CBC DECRYPT ------------------------------#
 587 .align  16
 588 .Lcbc_decrypt:
 589 ___
 590 $code.=<<___ if ($win64);
 591         lea     -0x58(%rsp),%rsp
 592         movaps  %xmm6,(%rsp)
 593         movaps  %xmm7,0x10(%rsp)
 594         movaps  %xmm8,0x20(%rsp)
 595         movaps  %xmm9,0x30(%rsp)
 596 .Lcbc_decrypt_body:
 597 ___
 598 $code.=<<___;
 599         movups  ($ivp),$iv
 600         cmp     \$0x40,$len
 601         mov     $rnds_,$rounds
 602         jbe     .Lcbc_dec_tail
 603         sub     \$0x40,$len
 604         jmp     .Lcbc_dec_loop3
 605 .align 16
 606 .Lcbc_dec_loop3:
 607         movups  ($inp),$inout0
 608         movups  0x10($inp),$inout1
 609         movups  0x20($inp),$inout2
 610         movaps  $inout0,$in0
 611         movaps  $inout1,$in1
 612         movaps  $inout2,$in2
 613         call    _aesni_decrypt3
 614         sub     \$0x30,$len
 615         lea     0x30($inp),$inp
 616         lea     0x30($out),$out
 617         pxor    $iv,$inout0
 618         pxor    $in0,$inout1
 619         movaps  $in2,$iv
 620         pxor    $in1,$inout2
 621         movups  $inout0,-0x30($out)
 622         mov     $rnds_,$rounds  # restore $rounds
 623         movups  $inout1,-0x20($out)
 624         mov     $key_,$key      # restore $key
 625         movups  $inout2,-0x10($out)
 626         ja      .Lcbc_dec_loop3
 627
 628         add     \$0x40,$len
 629         movups  $iv,($ivp)
 630         jz      .Lcbc_dec_ret
 631
 632 .Lcbc_dec_tail:
 633         movups  ($inp),$inout0
 634         cmp     \$0x10,$len
 635         movaps  $inout0,$in0
 636         jbe     .Lcbc_dec_one
 637         movups  0x10($inp),$inout1
 638         cmp     \$0x20,$len
 639         movaps  $inout1,$in1
 640         jbe     .Lcbc_dec_two
 641         movups  0x20($inp),$inout2
 642         cmp     \$0x30,$len
 643         movaps  $inout2,$in2
 644         jbe     .Lcbc_dec_three
 645         movups  0x30($inp),$inout3
 646         call    _aesni_decrypt4
 647         pxor    $iv,$inout0
 648         movups  0x30($inp),$iv
 649         pxor    $in0,$inout1
 650         movups  $inout0,($out)
 651         pxor    $in1,$inout2
 652         movups  $inout1,0x10($out)
 653         pxor    $in2,$inout3
 654         movups  $inout2,0x20($out)
 655         movaps  $inout3,$inout0
 656         lea     0x30($out),$out
 657         jmp     .Lcbc_dec_tail_collected
 658 .align  16
 659 .Lcbc_dec_one:
 660 ___
 661         &aesni_generate1("dec",$key,$rounds);
 662 $code.=<<___;
 663         pxor    $iv,$inout0
 664         movaps  $in0,$iv
 665         jmp     .Lcbc_dec_tail_collected
 666 .align  16
 667 .Lcbc_dec_two:
 668         call    _aesni_decrypt3
 669         pxor    $iv,$inout0
 670         pxor    $in0,$inout1
 671         movups  $inout0,($out)
 672         movaps  $in1,$iv
 673         movaps  $inout1,$inout0
 674         lea     0x10($out),$out
 675         jmp     .Lcbc_dec_tail_collected
 676 .align  16
 677 .Lcbc_dec_three:
 678         call    _aesni_decrypt3
 679         pxor    $iv,$inout0
 680         pxor    $in0,$inout1
 681         movups  $inout0,($out)
 682         pxor    $in1,$inout2
 683         movups  $inout1,0x10($out)
 684         movaps  $in2,$iv
 685         movaps  $inout2,$inout0
 686         lea     0x20($out),$out
 687         jmp     .Lcbc_dec_tail_collected
 688 .align  16
 689 .Lcbc_dec_tail_collected:
 690         and     \$15,$len
 691         movups  $iv,($ivp)
 692         jnz     .Lcbc_dec_tail_partial
 693         movups  $inout0,($out)
 694         jmp     .Lcbc_dec_ret
 695 .Lcbc_dec_tail_partial:
 696         movaps  $inout0,$reserved(%rsp)
 697         mov     $out,%rdi
 698         mov     $len,%rcx
 699         lea     $reserved(%rsp),%rsi
 700         .long   0x9066A4F3      # rep movsb
 701
 702 .Lcbc_dec_ret:
 703 ___
 704 $code.=<<___ if ($win64);
 705         movaps  (%rsp),%xmm6
 706         movaps  0x10(%rsp),%xmm7
 707         movaps  0x20(%rsp),%xmm8
 708         movaps  0x30(%rsp),%xmm9
 709         lea     0x58(%rsp),%rsp
 710 ___
 711 $code.=<<___;
 712 .Lcbc_ret:
 713         ret
 714 .size   ${PREFIX}_cbc_encrypt,.-${PREFIX}_cbc_encrypt
 715 ___
 716 \f
 717 # int $PREFIX_set_[en|de]crypt_key (const unsigned char *userKey,
 718 #                               int bits, AES_KEY *key)
 719 { my ($inp,$bits,$key) = @_4args;
 720   $bits =~ s/%r/%e/;
 721
 722 $code.=<<___;
 723 .globl  ${PREFIX}_set_decrypt_key
 724 .type   ${PREFIX}_set_decrypt_key,\@abi-omnipotent
 725 .align  16
 726 ${PREFIX}_set_decrypt_key:
 727         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
 728         call    _aesni_set_encrypt_key
 729         shl     \$4,$bits               # rounds-1 after _aesni_set_encrypt_key
 730         test    %eax,%eax
 731         jnz     .Ldec_key_ret
 732         lea     16($key,$bits),$inp     # points at the end of key schedule
 733
 734         $movkey ($key),%xmm0            # just swap
 735         $movkey ($inp),%xmm1
 736         $movkey %xmm0,($inp)
 737         $movkey %xmm1,($key)
 738         lea     16($key),$key
 739         lea     -16($inp),$inp
 740
 741 .Ldec_key_inverse:
 742         $movkey ($key),%xmm0            # swap and inverse
 743         $movkey ($inp),%xmm1
 744         aesimc  %xmm0,%xmm0
 745         aesimc  %xmm1,%xmm1
 746         lea     16($key),$key
 747         lea     -16($inp),$inp
 748         cmp     $key,$inp
 749         $movkey %xmm0,16($inp)
 750         $movkey %xmm1,-16($key)
 751         ja      .Ldec_key_inverse
 752
 753         $movkey ($key),%xmm0            # inverse middle
 754         aesimc  %xmm0,%xmm0
 755         $movkey %xmm0,($inp)
 756 .Ldec_key_ret:
 757         add     \$8,%rsp
 758         ret
 759 .LSEH_end_set_decrypt_key:
 760 .size   ${PREFIX}_set_decrypt_key,.-${PREFIX}_set_decrypt_key
 761 ___
 762 \f
 763 # This is based on submission by
 764 #
 765 #       Huang Ying <ying.huang@intel.com>
 766 #       Vinodh Gopal <vinodh.gopal@intel.com>
 767 #       Kahraman Akdemir
 768 #
 769 # Agressively optimized in respect to aeskeygenassist's critical path
 770 # and is contained in %xmm0-5 to meet Win64 ABI requirement.
 771 #
 772 $code.=<<___;
 773 .globl  ${PREFIX}_set_encrypt_key
 774 .type   ${PREFIX}_set_encrypt_key,\@abi-omnipotent
 775 .align  16
 776 ${PREFIX}_set_encrypt_key:
 777 _aesni_set_encrypt_key:
 778         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
 779         test    $inp,$inp
 780         mov     \$-1,%rax
 781         jz      .Lenc_key_ret
 782         test    $key,$key
 783         jz      .Lenc_key_ret
 784
 785         movups  ($inp),%xmm0            # pull first 128 bits of *userKey
 786         pxor    %xmm4,%xmm4             # low dword of xmm4 is assumed 0
 787         lea     16($key),%rax
 788         cmp     \$256,$bits
 789         je      .L14rounds
 790         cmp     \$192,$bits
 791         je      .L12rounds
 792         cmp     \$128,$bits
 793         jne     .Lbad_keybits
 794
 795 .L10rounds:
 796         mov     \$9,$bits                       # 10 rounds for 128-bit key
 797         $movkey %xmm0,($key)                    # round 0
 798         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 1
 799         call            .Lkey_expansion_128_cold
 800         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 2
 801         call            .Lkey_expansion_128
 802         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 3
 803         call            .Lkey_expansion_128
 804         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 4
 805         call            .Lkey_expansion_128
 806         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 5
 807         call            .Lkey_expansion_128
 808         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 6
 809         call            .Lkey_expansion_128
 810         aeskeygenassist \$0x40,%xmm0,%xmm1      # round 7
 811         call            .Lkey_expansion_128
 812         aeskeygenassist \$0x80,%xmm0,%xmm1      # round 8
 813         call            .Lkey_expansion_128
 814         aeskeygenassist \$0x1b,%xmm0,%xmm1      # round 9
 815         call            .Lkey_expansion_128
 816         aeskeygenassist \$0x36,%xmm0,%xmm1      # round 10
 817         call            .Lkey_expansion_128
 818         $movkey %xmm0,(%rax)
 819         mov     $bits,80(%rax)  # 240(%rdx)
 820         xor     %eax,%eax
 821         jmp     .Lenc_key_ret
 822
 823 .align  16
 824 .L12rounds:
 825         movq    16($inp),%xmm2                  # remaining 1/3 of *userKey
 826         mov     \$11,$bits                      # 12 rounds for 192
 827         $movkey %xmm0,($key)                    # round 0
 828         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 1,2
 829         call            .Lkey_expansion_192a_cold
 830         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 2,3
 831         call            .Lkey_expansion_192b
 832         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 4,5
 833         call            .Lkey_expansion_192a
 834         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 5,6
 835         call            .Lkey_expansion_192b
 836         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 7,8
 837         call            .Lkey_expansion_192a
 838         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 8,9
 839         call            .Lkey_expansion_192b
 840         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 10,11
 841         call            .Lkey_expansion_192a
 842         aeskeygenassist \$0x80,%xmm2,%xmm1      # round 11,12
 843         call            .Lkey_expansion_192b
 844         $movkey %xmm0,(%rax)
 845         mov     $bits,48(%rax)  # 240(%rdx)
 846         xor     %rax, %rax
 847         jmp     .Lenc_key_ret
 848
 849 .align  16
 850 .L14rounds:
 851         movups  16($inp),%xmm2                  # remaning half of *userKey
 852         mov     \$13,$bits                      # 14 rounds for 256
 853         lea     16(%rax),%rax
 854         $movkey %xmm0,($key)                    # round 0
 855         $movkey %xmm2,16($key)                  # round 1
 856         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 2
 857         call            .Lkey_expansion_256a_cold
 858         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 3
 859         call            .Lkey_expansion_256b
 860         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 4
 861         call            .Lkey_expansion_256a
 862         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 5
 863         call            .Lkey_expansion_256b
 864         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 6
 865         call            .Lkey_expansion_256a
 866         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 7
 867         call            .Lkey_expansion_256b
 868         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 8
 869         call            .Lkey_expansion_256a
 870         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 9
 871         call            .Lkey_expansion_256b
 872         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 10
 873         call            .Lkey_expansion_256a
 874         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 11
 875         call            .Lkey_expansion_256b
 876         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 12
 877         call            .Lkey_expansion_256a
 878         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 13
 879         call            .Lkey_expansion_256b
 880         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 14
 881         call            .Lkey_expansion_256a
 882         $movkey %xmm0,(%rax)
 883         mov     $bits,16(%rax)  # 240(%rdx)
 884         xor     %rax,%rax
 885         jmp     .Lenc_key_ret
 886
 887 .align  16
 888 .Lbad_keybits:
 889         mov     \$-2,%rax
 890 .Lenc_key_ret:
 891         add     \$8,%rsp
 892         ret
 893 .LSEH_end_set_encrypt_key:
 894 \f
 895 .align  16
 896 .Lkey_expansion_128:
 897         $movkey %xmm0,(%rax)
 898         lea     16(%rax),%rax
 899 .Lkey_expansion_128_cold:
 900         shufps  \$0b00010000,%xmm0,%xmm4
 901         pxor    %xmm4, %xmm0
 902         shufps  \$0b10001100,%xmm0,%xmm4
 903         pxor    %xmm4, %xmm0
 904         pshufd  \$0b11111111,%xmm1,%xmm1        # critical path
 905         pxor    %xmm1,%xmm0
 906         ret
 907
 908 .align 16
 909 .Lkey_expansion_192a:
 910         $movkey %xmm0,(%rax)
 911         lea     16(%rax),%rax
 912 .Lkey_expansion_192a_cold:
 913         movaps  %xmm2, %xmm5
 914 .Lkey_expansion_192b_warm:
 915         shufps  \$0b00010000,%xmm0,%xmm4
 916         movaps  %xmm2,%xmm3
 917         pxor    %xmm4,%xmm0
 918         shufps  \$0b10001100,%xmm0,%xmm4
 919         pslldq  \$4,%xmm3
 920         pxor    %xmm4,%xmm0
 921         pshufd  \$0b01010101,%xmm1,%xmm1        # critical path
 922         pxor    %xmm3,%xmm2
 923         pxor    %xmm1,%xmm0
 924         pshufd  \$0b11111111,%xmm0,%xmm3
 925         pxor    %xmm3,%xmm2
 926         ret
 927
 928 .align 16
 929 .Lkey_expansion_192b:
 930         movaps  %xmm0,%xmm3
 931         shufps  \$0b01000100,%xmm0,%xmm5
 932         $movkey %xmm5,(%rax)
 933         shufps  \$0b01001110,%xmm2,%xmm3
 934         $movkey %xmm3,16(%rax)
 935         lea     32(%rax),%rax
 936         jmp     .Lkey_expansion_192b_warm
 937
 938 .align  16
 939 .Lkey_expansion_256a:
 940         $movkey %xmm2,(%rax)
 941         lea     16(%rax),%rax
 942 .Lkey_expansion_256a_cold:
 943         shufps  \$0b00010000,%xmm0,%xmm4
 944         pxor    %xmm4,%xmm0
 945         shufps  \$0b10001100,%xmm0,%xmm4
 946         pxor    %xmm4,%xmm0
 947         pshufd  \$0b11111111,%xmm1,%xmm1        # critical path
 948         pxor    %xmm1,%xmm0
 949         ret
 950
 951 .align 16
 952 .Lkey_expansion_256b:
 953         $movkey %xmm0,(%rax)
 954         lea     16(%rax),%rax
 955
 956         shufps  \$0b00010000,%xmm2,%xmm4
 957         pxor    %xmm4,%xmm2
 958         shufps  \$0b10001100,%xmm2,%xmm4
 959         pxor    %xmm4,%xmm2
 960         pshufd  \$0b10101010,%xmm1,%xmm1        # critical path
 961         pxor    %xmm1,%xmm2
 962         ret
 963 .size   ${PREFIX}_set_encrypt_key,.-${PREFIX}_set_encrypt_key
 964 ___
 965 }
 966 \f
 967 $code.=<<___;
 968 .align  64
 969 .Lbswap_mask:
 970         .byte   15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
 971 .Lincrement:
 972         .long   3,3,3,0
 973 .asciz  "AES for Intel AES-NI, CRYPTOGAMS by <appro\@openssl.org>"
 974 .align  64
 975 ___
 976
 977 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
 978 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
 979 if ($win64) {
 980 $rec="%rcx";
 981 $frame="%rdx";
 982 $context="%r8";
 983 $disp="%r9";
 984
 985 $code.=<<___;
 986 .extern __imp_RtlVirtualUnwind
 987 ___
 988 $code.=<<___ if ($PREFIX eq "aesni");
 989 .type   ecb_se_handler,\@abi-omnipotent
 990 .align  16
 991 ecb_se_handler:
 992         push    %rsi
 993         push    %rdi
 994         push    %rbx
 995         push    %rbp
 996         push    %r12
 997         push    %r13
 998         push    %r14
 999         push    %r15
1000         pushfq
1001         sub     \$64,%rsp
1002
1003         mov     152($context),%rax      # pull context->Rsp
1004         mov     8(%rax),%rdi
1005         mov     16(%rax),%rsi
1006         mov     %rsi,168($context)      # restore context->Rsi
1007         mov     %rdi,176($context)      # restore context->Rdi
1008
1009         jmp     .Lcommon_seh_exit
1010 .size   ecb_se_handler,.-ecb_se_handler
1011
1012 .type   ctr32_se_handler,\@abi-omnipotent
1013 .align  16
1014 ctr32_se_handler:
1015         push    %rsi
1016         push    %rdi
1017         push    %rbx
1018         push    %rbp
1019         push    %r12
1020         push    %r13
1021         push    %r14
1022         push    %r15
1023         pushfq
1024         sub     \$64,%rsp
1025
1026         mov     120($context),%rax      # pull context->Rax
1027         mov     248($context),%rbx      # pull context->Rip
1028
1029         lea     .Lctr32_body(%rip),%r10
1030         cmp     %r10,%rbx               # context->Rip<"prologue" label
1031         jb      .Lin_ctr32_prologue
1032
1033         mov     152($context),%rax      # pull context->Rsp
1034
1035         lea     .Lctr32_ret(%rip),%r10
1036         cmp     %r10,%rbx
1037         jae     .Lin_ctr32_prologue
1038
1039         lea     0(%rax),%rsi            # top of stack
1040         lea     512($context),%rdi      # &context.Xmm6
1041         mov     \$12,%ecx               # 6*sizeof(%xmm0)/sizeof(%rax)
1042         .long   0xa548f3fc              # cld; rep movsq
1043         lea     0x68(%rax),%rax         # adjust stack pointer
1044
1045 .Lin_ctr32_prologue:
1046         mov     8(%rax),%rdi
1047         mov     16(%rax),%rsi
1048         mov     %rax,152($context)      # restore context->Rsp
1049         mov     %rsi,168($context)      # restore context->Rsi
1050         mov     %rdi,176($context)      # restore context->Rdi
1051
1052         jmp     .Lcommon_seh_exit
1053 .size   ctr32_se_handler,.-ctr32_se_handler
1054 ___
1055 $code.=<<___;
1056 .type   cbc_se_handler,\@abi-omnipotent
1057 .align  16
1058 cbc_se_handler:
1059         push    %rsi
1060         push    %rdi
1061         push    %rbx
1062         push    %rbp
1063         push    %r12
1064         push    %r13
1065         push    %r14
1066         push    %r15
1067         pushfq
1068         sub     \$64,%rsp
1069
1070         mov     152($context),%rax      # pull context->Rsp
1071         mov     248($context),%rbx      # pull context->Rip
1072
1073         lea     .Lcbc_decrypt(%rip),%r10
1074         cmp     %r10,%rbx               # context->Rip<"prologue" label
1075         jb      .Lin_cbc_prologue
1076
1077         lea     .Lcbc_decrypt_body(%rip),%r10
1078         cmp     %r10,%rbx               # context->Rip<cbc_decrypt_body
1079         jb      .Lrestore_cbc_rax
1080
1081         lea     .Lcbc_ret(%rip),%r10
1082         cmp     %r10,%rbx               # context->Rip>="epilogue" label
1083         jae     .Lin_cbc_prologue
1084
1085         lea     0(%rax),%rsi            # top of stack
1086         lea     512($context),%rdi      # &context.Xmm6
1087         mov     \$8,%ecx                # 4*sizeof(%xmm0)/sizeof(%rax)
1088         .long   0xa548f3fc              # cld; rep movsq
1089         lea     0x58(%rax),%rax         # adjust stack pointer
1090         jmp     .Lin_cbc_prologue
1091
1092 .Lrestore_cbc_rax:
1093         mov     120($context),%rax
1094 .Lin_cbc_prologue:
1095         mov     8(%rax),%rdi
1096         mov     16(%rax),%rsi
1097         mov     %rax,152($context)      # restore context->Rsp
1098         mov     %rsi,168($context)      # restore context->Rsi
1099         mov     %rdi,176($context)      # restore context->Rdi
1100
1101 .Lcommon_seh_exit:
1102
1103         mov     40($disp),%rdi          # disp->ContextRecord
1104         mov     $context,%rsi           # context
1105         mov     \$154,%ecx              # sizeof(CONTEXT)
1106         .long   0xa548f3fc              # cld; rep movsq
1107
1108         mov     $disp,%rsi
1109         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
1110         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
1111         mov     0(%rsi),%r8             # arg3, disp->ControlPc
1112         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
1113         mov     40(%rsi),%r10           # disp->ContextRecord
1114         lea     56(%rsi),%r11           # &disp->HandlerData
1115         lea     24(%rsi),%r12           # &disp->EstablisherFrame
1116         mov     %r10,32(%rsp)           # arg5
1117         mov     %r11,40(%rsp)           # arg6
1118         mov     %r12,48(%rsp)           # arg7
1119         mov     %rcx,56(%rsp)           # arg8, (NULL)
1120         call    *__imp_RtlVirtualUnwind(%rip)
1121
1122         mov     \$1,%eax                # ExceptionContinueSearch
1123         add     \$64,%rsp
1124         popfq
1125         pop     %r15
1126         pop     %r14
1127         pop     %r13
1128         pop     %r12
1129         pop     %rbp
1130         pop     %rbx
1131         pop     %rdi
1132         pop     %rsi
1133         ret
1134 .size   cbc_se_handler,.-cbc_se_handler
1135
1136 .section        .pdata
1137 .align  4
1138 ___
1139 $code.=<<___ if ($PREFIX eq "aesni");
1140         .rva    .LSEH_begin_aesni_ecb_encrypt
1141         .rva    .LSEH_end_aesni_ecb_encrypt
1142         .rva    .LSEH_info_ecb
1143
1144         .rva    .LSEH_begin_aesni_ctr32_encrypt_blocks
1145         .rva    .LSEH_end_aesni_ctr32_encrypt_blocks
1146         .rva    .LSEH_info_ctr32
1147 ___
1148 $code.=<<___;
1149         .rva    .LSEH_begin_${PREFIX}_cbc_encrypt
1150         .rva    .LSEH_end_${PREFIX}_cbc_encrypt
1151         .rva    .LSEH_info_cbc
1152
1153         .rva    ${PREFIX}_set_decrypt_key
1154         .rva    .LSEH_end_set_decrypt_key
1155         .rva    .LSEH_info_key
1156
1157         .rva    ${PREFIX}_set_encrypt_key
1158         .rva    .LSEH_end_set_encrypt_key
1159         .rva    .LSEH_info_key
1160 .section        .xdata
1161 .align  8
1162 ___
1163 $code.=<<___ if ($PREFIX eq "aesni");
1164 .LSEH_info_ecb:
1165         .byte   9,0,0,0
1166         .rva    ecb_se_handler
1167 .LSEH_info_ctr32:
1168         .byte   9,0,0,0
1169         .rva    ctr32_se_handler
1170 ___
1171 $code.=<<___;
1172 .LSEH_info_cbc:
1173         .byte   9,0,0,0
1174         .rva    cbc_se_handler
1175 .LSEH_info_key:
1176         .byte   0x01,0x04,0x01,0x00
1177         .byte   0x04,0x02,0x00,0x00
1178 ___
1179 }
1180
1181 sub rex {
1182  local *opcode=shift;
1183  my ($dst,$src)=@_;
1184
1185    if ($dst>=8 || $src>=8) {
1186         $rex=0x40;
1187         $rex|=0x04 if($dst>=8);
1188         $rex|=0x01 if($src>=8);
1189         push @opcode,$rex;
1190    }
1191 }
1192
1193 sub aesni {
1194   my $line=shift;
1195   my @opcode=(0x66);
1196
1197     if ($line=~/(aeskeygenassist)\s+\$([x0-9a-f]+),\s*%xmm([0-9]+),\s*%xmm([0-9]+)/) {
1198         rex(\@opcode,$4,$3);
1199         push @opcode,0x0f,0x3a,0xdf;
1200         push @opcode,0xc0|($3&7)|(($4&7)<<3);   # ModR/M
1201         my $c=$2;
1202         push @opcode,$c=~/^0/?oct($c):$c;
1203         return ".byte\t".join(',',@opcode);
1204     }
1205     elsif ($line=~/(aes[a-z]+)\s+%xmm([0-9]+),\s*%xmm([0-9]+)/) {
1206         my %opcodelet = (
1207                 "aesimc" => 0xdb,
1208                 "aesenc" => 0xdc,       "aesenclast" => 0xdd,
1209                 "aesdec" => 0xde,       "aesdeclast" => 0xdf
1210         );
1211         return undef if (!defined($opcodelet{$1}));
1212         rex(\@opcode,$3,$2);
1213         push @opcode,0x0f,0x38,$opcodelet{$1};
1214         push @opcode,0xc0|($2&7)|(($3&7)<<3);   # ModR/M
1215         return ".byte\t".join(',',@opcode);
1216     }
1217     return $line;
1218 }
1219
1220 $code =~ s/\`([^\`]*)\`/eval($1)/gem;
1221 $code =~ s/\b(aes.*%xmm[0-9]+).*$/aesni($1)/gem;
1222
1223 print $code;
1224
1225 close STDOUT;