708fabd3de364c6dbc1f27fbd581f575df78138a
[openssl.git] / crypto / aes / asm / aesni-x86_64.pl
1 #!/usr/bin/env perl
2 #
3 # ====================================================================
4 # Written by Andy Polyakov <appro@openssl.org> 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 it's 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 # January 2011
83 #
84 # While Westmere processor features 6 cycles latency for aes[enc|dec]
85 # instructions, which can be scheduled every second cycle, Sandy
86 # Bridge spends 8 cycles per instruction, but it can schedule them
87 # every cycle. This means that code targeting Westmere would perform
88 # suboptimally on Sandy Bridge. Therefore this update.
89 #
90 # In addition, non-parallelizable CBC encrypt (as well as CCM) is
91 # optimized. Relative improvement might appear modest, 8% on Westmere,
92 # but in absolute terms it's 3.77 cycles per byte encrypted with
93 # 128-bit key on Westmere, and 5.07 - on Sandy Bridge. These numbers
94 # should be compared to asymptotic limits of 3.75 for Westmere and
95 # 5.00 for Sandy Bridge. Actually, the fact that they get this close
96 # to asymptotic limits is quite amazing. Indeed, the limit is
97 # calculated as latency times number of rounds, 10 for 128-bit key,
98 # and divided by 16, the number of bytes in block, or in other words
99 # it accounts *solely* for aesenc instructions. But there are extra
100 # instructions, and numbers so close to the asymptotic limits mean
101 # that it's as if it takes as little as *one* additional cycle to
102 # execute all of them. How is it possible? It is possible thanks to
103 # out-of-order execution logic, which manages to overlap post-
104 # processing of previous block, things like saving the output, with
105 # actual encryption of current block, as well as pre-processing of
106 # current block, things like fetching input and xor-ing it with
107 # 0-round element of the key schedule, with actual encryption of
108 # previous block. Keep this in mind...
109 #
110 # For parallelizable modes, such as ECB, CBC decrypt, CTR, higher
111 # performance is achieved by interleaving instructions working on
112 # independent blocks. In which case asymptotic limit for such modes
113 # can be obtained by dividing above mentioned numbers by AES
114 # instructions' interleave factor. Westmere can execute at most 3 
115 # instructions at a time, meaning that optimal interleave factor is 3,
116 # and that's where the "magic" number of 1.25 come from. "Optimal
117 # interleave factor" means that increase of interleave factor does
118 # not improve performance. The formula has proven to reflect reality
119 # pretty well on Westmere... Sandy Bridge on the other hand can
120 # execute up to 8 AES instructions at a time, so how does varying
121 # interleave factor affect the performance? Here is table for ECB
122 # (numbers are cycles per byte processed with 128-bit key):
123 #
124 # instruction interleave factor         3x      6x      8x
125 # theoretical asymptotic limit          1.67    0.83    0.625
126 # measured performance for 8KB block    1.05    0.86    0.84
127 #
128 # "as if" interleave factor             4.7x    5.8x    6.0x
129 #
130 # Further data for other parallelizable modes:
131 #
132 # CBC decrypt                           1.16    0.93    0.74
133 # CTR                                   1.14    0.91    0.74
134 #
135 # Well, given 3x column it's probably inappropriate to call the limit
136 # asymptotic, if it can be surpassed, isn't it? What happens there?
137 # Rewind to CBC paragraph for the answer. Yes, out-of-order execution
138 # magic is responsible for this. Processor overlaps not only the
139 # additional instructions with AES ones, but even AES instuctions
140 # processing adjacent triplets of independent blocks. In the 6x case
141 # additional instructions  still claim disproportionally small amount
142 # of additional cycles, but in 8x case number of instructions must be
143 # a tad too high for out-of-order logic to cope with, and AES unit
144 # remains underutilized... As you can see 8x interleave is hardly
145 # justifiable, so there no need to feel bad that 32-bit aesni-x86.pl
146 # utilizies 6x interleave because of limited register bank capacity.
147 #
148 # Higher interleave factors do have negative impact on Westmere
149 # performance. While for ECB mode it's negligible ~1.5%, other
150 # parallelizables perform ~5% worse, which is outweighed by ~25%
151 # improvement on Sandy Bridge. To balance regression on Westmere
152 # CTR mode was implemented with 6x aesenc interleave factor.
153
154 # April 2011
155 #
156 # Add aesni_xts_[en|de]crypt. Westmere spends 1.25 cycles processing
157 # one byte out of 8KB with 128-bit key, Sandy Bridge - 0.90. Just like
158 # in CTR mode AES instruction interleave factor was chosen to be 6x.
159
160 ######################################################################
161 # Current large-block performance in cycles per byte processed with
162 # 128-bit key (less is better).
163 #
164 #               CBC en-/decrypt CTR     XTS     ECB
165 # Westmere      3.77/1.25       1.25    1.25    1.26
166 # * Bridge      5.07/0.74       0.75    0.90    0.85
167 # Haswell       4.44/0.63       0.63    0.73    0.63
168 # Atom          5.75/3.54       3.56    4.12    3.87(*)
169 # Bulldozer     5.77/0.70       0.72    0.90    0.70
170 #
171 # (*)   Atom ECB result is suboptimal because of penalties incurred
172 #       by operations on %xmm8-15. As ECB is not considered
173 #       critical, nothing was done to mitigate the problem.
174
175 $PREFIX="aesni";        # if $PREFIX is set to "AES", the script
176                         # generates drop-in replacement for
177                         # crypto/aes/asm/aes-x86_64.pl:-)
178
179 $flavour = shift;
180 $output  = shift;
181 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
182
183 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
184
185 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
186 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
187 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
188 die "can't locate x86_64-xlate.pl";
189
190 open OUT,"| \"$^X\" $xlate $flavour $output";
191 *STDOUT=*OUT;
192
193 $movkey = $PREFIX eq "aesni" ? "movups" : "movups";
194 @_4args=$win64? ("%rcx","%rdx","%r8", "%r9") :  # Win64 order
195                 ("%rdi","%rsi","%rdx","%rcx");  # Unix order
196
197 $code=".text\n";
198 $code.=".extern OPENSSL_ia32cap_P\n";
199
200 $rounds="%eax"; # input to and changed by aesni_[en|de]cryptN !!!
201 # this is natural Unix argument order for public $PREFIX_[ecb|cbc]_encrypt ...
202 $inp="%rdi";
203 $out="%rsi";
204 $len="%rdx";
205 $key="%rcx";    # input to and changed by aesni_[en|de]cryptN !!!
206 $ivp="%r8";     # cbc, ctr, ...
207
208 $rnds_="%r10d"; # backup copy for $rounds
209 $key_="%r11";   # backup copy for $key
210
211 # %xmm register layout
212 $rndkey0="%xmm0";       $rndkey1="%xmm1";
213 $inout0="%xmm2";        $inout1="%xmm3";
214 $inout2="%xmm4";        $inout3="%xmm5";
215 $inout4="%xmm6";        $inout5="%xmm7";
216 $inout6="%xmm8";        $inout7="%xmm9";
217
218 $in2="%xmm6";           $in1="%xmm7";   # used in CBC decrypt, CTR, ...
219 $in0="%xmm8";           $iv="%xmm9";
220 \f
221 # Inline version of internal aesni_[en|de]crypt1.
222 #
223 # Why folded loop? Because aes[enc|dec] is slow enough to accommodate
224 # cycles which take care of loop variables...
225 { my $sn;
226 sub aesni_generate1 {
227 my ($p,$key,$rounds,$inout,$ivec)=@_;   $inout=$inout0 if (!defined($inout));
228 ++$sn;
229 $code.=<<___;
230         $movkey ($key),$rndkey0
231         $movkey 16($key),$rndkey1
232 ___
233 $code.=<<___ if (defined($ivec));
234         xorps   $rndkey0,$ivec
235         lea     32($key),$key
236         xorps   $ivec,$inout
237 ___
238 $code.=<<___ if (!defined($ivec));
239         lea     32($key),$key
240         xorps   $rndkey0,$inout
241 ___
242 $code.=<<___;
243 .Loop_${p}1_$sn:
244         aes${p} $rndkey1,$inout
245         dec     $rounds
246         $movkey ($key),$rndkey1
247         lea     16($key),$key
248         jnz     .Loop_${p}1_$sn # loop body is 16 bytes
249         aes${p}last     $rndkey1,$inout
250 ___
251 }}
252 # void $PREFIX_[en|de]crypt (const void *inp,void *out,const AES_KEY *key);
253 #
254 { my ($inp,$out,$key) = @_4args;
255
256 $code.=<<___;
257 .globl  ${PREFIX}_encrypt
258 .type   ${PREFIX}_encrypt,\@abi-omnipotent
259 .align  16
260 ${PREFIX}_encrypt:
261         movups  ($inp),$inout0          # load input
262         mov     240($key),$rounds       # key->rounds
263 ___
264         &aesni_generate1("enc",$key,$rounds);
265 $code.=<<___;
266         movups  $inout0,($out)          # output
267         ret
268 .size   ${PREFIX}_encrypt,.-${PREFIX}_encrypt
269
270 .globl  ${PREFIX}_decrypt
271 .type   ${PREFIX}_decrypt,\@abi-omnipotent
272 .align  16
273 ${PREFIX}_decrypt:
274         movups  ($inp),$inout0          # load input
275         mov     240($key),$rounds       # key->rounds
276 ___
277         &aesni_generate1("dec",$key,$rounds);
278 $code.=<<___;
279         movups  $inout0,($out)          # output
280         ret
281 .size   ${PREFIX}_decrypt, .-${PREFIX}_decrypt
282 ___
283 }
284 \f
285 # _aesni_[en|de]cryptN are private interfaces, N denotes interleave
286 # factor. Why 3x subroutine were originally used in loops? Even though
287 # aes[enc|dec] latency was originally 6, it could be scheduled only
288 # every *2nd* cycle. Thus 3x interleave was the one providing optimal
289 # utilization, i.e. when subroutine's throughput is virtually same as
290 # of non-interleaved subroutine [for number of input blocks up to 3].
291 # This is why it makes no sense to implement 2x subroutine.
292 # aes[enc|dec] latency in next processor generation is 8, but the
293 # instructions can be scheduled every cycle. Optimal interleave for
294 # new processor is therefore 8x...
295 sub aesni_generate3 {
296 my $dir=shift;
297 # As already mentioned it takes in $key and $rounds, which are *not*
298 # preserved. $inout[0-2] is cipher/clear text...
299 $code.=<<___;
300 .type   _aesni_${dir}rypt3,\@abi-omnipotent
301 .align  16
302 _aesni_${dir}rypt3:
303         $movkey ($key),$rndkey0
304         shl     \$4,$rounds
305         $movkey 16($key),$rndkey1
306         xorps   $rndkey0,$inout0
307         xorps   $rndkey0,$inout1
308         xorps   $rndkey0,$inout2
309         $movkey 32($key),$rndkey0
310         lea     32($key,$rounds),$key
311         neg     %rax                            # $rounds
312         add     \$16,%rax
313
314 .L${dir}_loop3:
315         aes${dir}       $rndkey1,$inout0
316         aes${dir}       $rndkey1,$inout1
317         aes${dir}       $rndkey1,$inout2
318         $movkey         ($key,%rax),$rndkey1
319         add             \$32,%rax
320         aes${dir}       $rndkey0,$inout0
321         aes${dir}       $rndkey0,$inout1
322         aes${dir}       $rndkey0,$inout2
323         $movkey         -16($key,%rax),$rndkey0
324         jnz             .L${dir}_loop3
325
326         aes${dir}       $rndkey1,$inout0
327         aes${dir}       $rndkey1,$inout1
328         aes${dir}       $rndkey1,$inout2
329         aes${dir}last   $rndkey0,$inout0
330         aes${dir}last   $rndkey0,$inout1
331         aes${dir}last   $rndkey0,$inout2
332         ret
333 .size   _aesni_${dir}rypt3,.-_aesni_${dir}rypt3
334 ___
335 }
336 # 4x interleave is implemented to improve small block performance,
337 # most notably [and naturally] 4 block by ~30%. One can argue that one
338 # should have implemented 5x as well, but improvement would be <20%,
339 # so it's not worth it...
340 sub aesni_generate4 {
341 my $dir=shift;
342 # As already mentioned it takes in $key and $rounds, which are *not*
343 # preserved. $inout[0-3] is cipher/clear text...
344 $code.=<<___;
345 .type   _aesni_${dir}rypt4,\@abi-omnipotent
346 .align  16
347 _aesni_${dir}rypt4:
348         $movkey ($key),$rndkey0
349         shl     \$4,$rounds
350         $movkey 16($key),$rndkey1
351         xorps   $rndkey0,$inout0
352         xorps   $rndkey0,$inout1
353         xorps   $rndkey0,$inout2
354         xorps   $rndkey0,$inout3
355         $movkey 32($key),$rndkey0
356         lea     32($key,$rounds),$key
357         neg     %rax                            # $rounds
358         .byte   0x0f,0x1f,0x00
359         add     \$16,%rax
360
361 .L${dir}_loop4:
362         aes${dir}       $rndkey1,$inout0
363         aes${dir}       $rndkey1,$inout1
364         aes${dir}       $rndkey1,$inout2
365         aes${dir}       $rndkey1,$inout3
366         $movkey         ($key,%rax),$rndkey1
367         add             \$32,%rax
368         aes${dir}       $rndkey0,$inout0
369         aes${dir}       $rndkey0,$inout1
370         aes${dir}       $rndkey0,$inout2
371         aes${dir}       $rndkey0,$inout3
372         $movkey         -16($key,%rax),$rndkey0
373         jnz             .L${dir}_loop4
374
375         aes${dir}       $rndkey1,$inout0
376         aes${dir}       $rndkey1,$inout1
377         aes${dir}       $rndkey1,$inout2
378         aes${dir}       $rndkey1,$inout3
379         aes${dir}last   $rndkey0,$inout0
380         aes${dir}last   $rndkey0,$inout1
381         aes${dir}last   $rndkey0,$inout2
382         aes${dir}last   $rndkey0,$inout3
383         ret
384 .size   _aesni_${dir}rypt4,.-_aesni_${dir}rypt4
385 ___
386 }
387 sub aesni_generate6 {
388 my $dir=shift;
389 # As already mentioned it takes in $key and $rounds, which are *not*
390 # preserved. $inout[0-5] is cipher/clear text...
391 $code.=<<___;
392 .type   _aesni_${dir}rypt6,\@abi-omnipotent
393 .align  16
394 _aesni_${dir}rypt6:
395         $movkey         ($key),$rndkey0
396         shl             \$4,$rounds
397         $movkey         16($key),$rndkey1
398         xorps           $rndkey0,$inout0
399         pxor            $rndkey0,$inout1
400         pxor            $rndkey0,$inout2
401         aes${dir}       $rndkey1,$inout0
402         lea             32($key,$rounds),$key
403         neg             %rax                    # $rounds
404         aes${dir}       $rndkey1,$inout1
405         pxor            $rndkey0,$inout3
406         pxor            $rndkey0,$inout4
407         aes${dir}       $rndkey1,$inout2
408         pxor            $rndkey0,$inout5
409         add             \$16,%rax
410         aes${dir}       $rndkey1,$inout3
411         aes${dir}       $rndkey1,$inout4
412         aes${dir}       $rndkey1,$inout5
413         $movkey         -16($key,%rax),$rndkey0
414         jmp             .L${dir}_loop6_enter
415 .align  16
416 .L${dir}_loop6:
417         aes${dir}       $rndkey1,$inout0
418         aes${dir}       $rndkey1,$inout1
419         aes${dir}       $rndkey1,$inout2
420         aes${dir}       $rndkey1,$inout3
421         aes${dir}       $rndkey1,$inout4
422         aes${dir}       $rndkey1,$inout5
423 .L${dir}_loop6_enter:
424         $movkey         ($key,%rax),$rndkey1
425         add             \$32,%rax
426         aes${dir}       $rndkey0,$inout0
427         aes${dir}       $rndkey0,$inout1
428         aes${dir}       $rndkey0,$inout2
429         aes${dir}       $rndkey0,$inout3
430         aes${dir}       $rndkey0,$inout4
431         aes${dir}       $rndkey0,$inout5
432         $movkey         -16($key,%rax),$rndkey0
433         jnz             .L${dir}_loop6
434
435         aes${dir}       $rndkey1,$inout0
436         aes${dir}       $rndkey1,$inout1
437         aes${dir}       $rndkey1,$inout2
438         aes${dir}       $rndkey1,$inout3
439         aes${dir}       $rndkey1,$inout4
440         aes${dir}       $rndkey1,$inout5
441         aes${dir}last   $rndkey0,$inout0
442         aes${dir}last   $rndkey0,$inout1
443         aes${dir}last   $rndkey0,$inout2
444         aes${dir}last   $rndkey0,$inout3
445         aes${dir}last   $rndkey0,$inout4
446         aes${dir}last   $rndkey0,$inout5
447         ret
448 .size   _aesni_${dir}rypt6,.-_aesni_${dir}rypt6
449 ___
450 }
451 sub aesni_generate8 {
452 my $dir=shift;
453 # As already mentioned it takes in $key and $rounds, which are *not*
454 # preserved. $inout[0-7] is cipher/clear text...
455 $code.=<<___;
456 .type   _aesni_${dir}rypt8,\@abi-omnipotent
457 .align  16
458 _aesni_${dir}rypt8:
459         $movkey         ($key),$rndkey0
460         shl             \$4,$rounds
461         $movkey         16($key),$rndkey1
462         xorps           $rndkey0,$inout0
463         xorps           $rndkey0,$inout1
464         pxor            $rndkey0,$inout2
465         pxor            $rndkey0,$inout3
466         pxor            $rndkey0,$inout4
467         lea             32($key,$rounds),$key
468         neg             %rax                    # $rounds
469         aes${dir}       $rndkey1,$inout0
470         add             \$16,%rax
471         pxor            $rndkey0,$inout5
472         aes${dir}       $rndkey1,$inout1
473         pxor            $rndkey0,$inout6
474         pxor            $rndkey0,$inout7
475         aes${dir}       $rndkey1,$inout2
476         aes${dir}       $rndkey1,$inout3
477         aes${dir}       $rndkey1,$inout4
478         aes${dir}       $rndkey1,$inout5
479         aes${dir}       $rndkey1,$inout6
480         aes${dir}       $rndkey1,$inout7
481         $movkey         -16($key,%rax),$rndkey0
482         jmp             .L${dir}_loop8_enter
483 .align  16
484 .L${dir}_loop8:
485         aes${dir}       $rndkey1,$inout0
486         aes${dir}       $rndkey1,$inout1
487         aes${dir}       $rndkey1,$inout2
488         aes${dir}       $rndkey1,$inout3
489         aes${dir}       $rndkey1,$inout4
490         aes${dir}       $rndkey1,$inout5
491         aes${dir}       $rndkey1,$inout6
492         aes${dir}       $rndkey1,$inout7
493 .L${dir}_loop8_enter:
494         $movkey         ($key,%rax),$rndkey1
495         add             \$32,%rax
496         aes${dir}       $rndkey0,$inout0
497         aes${dir}       $rndkey0,$inout1
498         aes${dir}       $rndkey0,$inout2
499         aes${dir}       $rndkey0,$inout3
500         aes${dir}       $rndkey0,$inout4
501         aes${dir}       $rndkey0,$inout5
502         aes${dir}       $rndkey0,$inout6
503         aes${dir}       $rndkey0,$inout7
504         $movkey         -16($key,%rax),$rndkey0
505         jnz             .L${dir}_loop8
506
507         aes${dir}       $rndkey1,$inout0
508         aes${dir}       $rndkey1,$inout1
509         aes${dir}       $rndkey1,$inout2
510         aes${dir}       $rndkey1,$inout3
511         aes${dir}       $rndkey1,$inout4
512         aes${dir}       $rndkey1,$inout5
513         aes${dir}       $rndkey1,$inout6
514         aes${dir}       $rndkey1,$inout7
515         aes${dir}last   $rndkey0,$inout0
516         aes${dir}last   $rndkey0,$inout1
517         aes${dir}last   $rndkey0,$inout2
518         aes${dir}last   $rndkey0,$inout3
519         aes${dir}last   $rndkey0,$inout4
520         aes${dir}last   $rndkey0,$inout5
521         aes${dir}last   $rndkey0,$inout6
522         aes${dir}last   $rndkey0,$inout7
523         ret
524 .size   _aesni_${dir}rypt8,.-_aesni_${dir}rypt8
525 ___
526 }
527 &aesni_generate3("enc") if ($PREFIX eq "aesni");
528 &aesni_generate3("dec");
529 &aesni_generate4("enc") if ($PREFIX eq "aesni");
530 &aesni_generate4("dec");
531 &aesni_generate6("enc") if ($PREFIX eq "aesni");
532 &aesni_generate6("dec");
533 &aesni_generate8("enc") if ($PREFIX eq "aesni");
534 &aesni_generate8("dec");
535 \f
536 if ($PREFIX eq "aesni") {
537 ########################################################################
538 # void aesni_ecb_encrypt (const void *in, void *out,
539 #                         size_t length, const AES_KEY *key,
540 #                         int enc);
541 $code.=<<___;
542 .globl  aesni_ecb_encrypt
543 .type   aesni_ecb_encrypt,\@function,5
544 .align  16
545 aesni_ecb_encrypt:
546         and     \$-16,$len
547         jz      .Lecb_ret
548
549         mov     240($key),$rounds       # key->rounds
550         $movkey ($key),$rndkey0
551         mov     $key,$key_              # backup $key
552         mov     $rounds,$rnds_          # backup $rounds
553         test    %r8d,%r8d               # 5th argument
554         jz      .Lecb_decrypt
555 #--------------------------- ECB ENCRYPT ------------------------------#
556         cmp     \$0x80,$len
557         jb      .Lecb_enc_tail
558
559         movdqu  ($inp),$inout0
560         movdqu  0x10($inp),$inout1
561         movdqu  0x20($inp),$inout2
562         movdqu  0x30($inp),$inout3
563         movdqu  0x40($inp),$inout4
564         movdqu  0x50($inp),$inout5
565         movdqu  0x60($inp),$inout6
566         movdqu  0x70($inp),$inout7
567         lea     0x80($inp),$inp
568         sub     \$0x80,$len
569         jmp     .Lecb_enc_loop8_enter
570 .align 16
571 .Lecb_enc_loop8:
572         movups  $inout0,($out)
573         mov     $key_,$key              # restore $key
574         movdqu  ($inp),$inout0
575         mov     $rnds_,$rounds          # restore $rounds
576         movups  $inout1,0x10($out)
577         movdqu  0x10($inp),$inout1
578         movups  $inout2,0x20($out)
579         movdqu  0x20($inp),$inout2
580         movups  $inout3,0x30($out)
581         movdqu  0x30($inp),$inout3
582         movups  $inout4,0x40($out)
583         movdqu  0x40($inp),$inout4
584         movups  $inout5,0x50($out)
585         movdqu  0x50($inp),$inout5
586         movups  $inout6,0x60($out)
587         movdqu  0x60($inp),$inout6
588         movups  $inout7,0x70($out)
589         lea     0x80($out),$out
590         movdqu  0x70($inp),$inout7
591         lea     0x80($inp),$inp
592 .Lecb_enc_loop8_enter:
593
594         call    _aesni_encrypt8
595
596         sub     \$0x80,$len
597         jnc     .Lecb_enc_loop8
598
599         movups  $inout0,($out)
600         mov     $key_,$key              # restore $key
601         movups  $inout1,0x10($out)
602         mov     $rnds_,$rounds          # restore $rounds
603         movups  $inout2,0x20($out)
604         movups  $inout3,0x30($out)
605         movups  $inout4,0x40($out)
606         movups  $inout5,0x50($out)
607         movups  $inout6,0x60($out)
608         movups  $inout7,0x70($out)
609         lea     0x80($out),$out
610         add     \$0x80,$len
611         jz      .Lecb_ret
612
613 .Lecb_enc_tail:
614         movups  ($inp),$inout0
615         cmp     \$0x20,$len
616         jb      .Lecb_enc_one
617         movups  0x10($inp),$inout1
618         je      .Lecb_enc_two
619         movups  0x20($inp),$inout2
620         cmp     \$0x40,$len
621         jb      .Lecb_enc_three
622         movups  0x30($inp),$inout3
623         je      .Lecb_enc_four
624         movups  0x40($inp),$inout4
625         cmp     \$0x60,$len
626         jb      .Lecb_enc_five
627         movups  0x50($inp),$inout5
628         je      .Lecb_enc_six
629         movdqu  0x60($inp),$inout6
630         call    _aesni_encrypt8
631         movups  $inout0,($out)
632         movups  $inout1,0x10($out)
633         movups  $inout2,0x20($out)
634         movups  $inout3,0x30($out)
635         movups  $inout4,0x40($out)
636         movups  $inout5,0x50($out)
637         movups  $inout6,0x60($out)
638         jmp     .Lecb_ret
639 .align  16
640 .Lecb_enc_one:
641 ___
642         &aesni_generate1("enc",$key,$rounds);
643 $code.=<<___;
644         movups  $inout0,($out)
645         jmp     .Lecb_ret
646 .align  16
647 .Lecb_enc_two:
648         xorps   $inout2,$inout2
649         call    _aesni_encrypt3
650         movups  $inout0,($out)
651         movups  $inout1,0x10($out)
652         jmp     .Lecb_ret
653 .align  16
654 .Lecb_enc_three:
655         call    _aesni_encrypt3
656         movups  $inout0,($out)
657         movups  $inout1,0x10($out)
658         movups  $inout2,0x20($out)
659         jmp     .Lecb_ret
660 .align  16
661 .Lecb_enc_four:
662         call    _aesni_encrypt4
663         movups  $inout0,($out)
664         movups  $inout1,0x10($out)
665         movups  $inout2,0x20($out)
666         movups  $inout3,0x30($out)
667         jmp     .Lecb_ret
668 .align  16
669 .Lecb_enc_five:
670         xorps   $inout5,$inout5
671         call    _aesni_encrypt6
672         movups  $inout0,($out)
673         movups  $inout1,0x10($out)
674         movups  $inout2,0x20($out)
675         movups  $inout3,0x30($out)
676         movups  $inout4,0x40($out)
677         jmp     .Lecb_ret
678 .align  16
679 .Lecb_enc_six:
680         call    _aesni_encrypt6
681         movups  $inout0,($out)
682         movups  $inout1,0x10($out)
683         movups  $inout2,0x20($out)
684         movups  $inout3,0x30($out)
685         movups  $inout4,0x40($out)
686         movups  $inout5,0x50($out)
687         jmp     .Lecb_ret
688 \f#--------------------------- ECB DECRYPT ------------------------------#
689 .align  16
690 .Lecb_decrypt:
691         cmp     \$0x80,$len
692         jb      .Lecb_dec_tail
693
694         movdqu  ($inp),$inout0
695         movdqu  0x10($inp),$inout1
696         movdqu  0x20($inp),$inout2
697         movdqu  0x30($inp),$inout3
698         movdqu  0x40($inp),$inout4
699         movdqu  0x50($inp),$inout5
700         movdqu  0x60($inp),$inout6
701         movdqu  0x70($inp),$inout7
702         lea     0x80($inp),$inp
703         sub     \$0x80,$len
704         jmp     .Lecb_dec_loop8_enter
705 .align 16
706 .Lecb_dec_loop8:
707         movups  $inout0,($out)
708         mov     $key_,$key              # restore $key
709         movdqu  ($inp),$inout0
710         mov     $rnds_,$rounds          # restore $rounds
711         movups  $inout1,0x10($out)
712         movdqu  0x10($inp),$inout1
713         movups  $inout2,0x20($out)
714         movdqu  0x20($inp),$inout2
715         movups  $inout3,0x30($out)
716         movdqu  0x30($inp),$inout3
717         movups  $inout4,0x40($out)
718         movdqu  0x40($inp),$inout4
719         movups  $inout5,0x50($out)
720         movdqu  0x50($inp),$inout5
721         movups  $inout6,0x60($out)
722         movdqu  0x60($inp),$inout6
723         movups  $inout7,0x70($out)
724         lea     0x80($out),$out
725         movdqu  0x70($inp),$inout7
726         lea     0x80($inp),$inp
727 .Lecb_dec_loop8_enter:
728
729         call    _aesni_decrypt8
730
731         $movkey ($key_),$rndkey0
732         sub     \$0x80,$len
733         jnc     .Lecb_dec_loop8
734
735         movups  $inout0,($out)
736         mov     $key_,$key              # restore $key
737         movups  $inout1,0x10($out)
738         mov     $rnds_,$rounds          # restore $rounds
739         movups  $inout2,0x20($out)
740         movups  $inout3,0x30($out)
741         movups  $inout4,0x40($out)
742         movups  $inout5,0x50($out)
743         movups  $inout6,0x60($out)
744         movups  $inout7,0x70($out)
745         lea     0x80($out),$out
746         add     \$0x80,$len
747         jz      .Lecb_ret
748
749 .Lecb_dec_tail:
750         movups  ($inp),$inout0
751         cmp     \$0x20,$len
752         jb      .Lecb_dec_one
753         movups  0x10($inp),$inout1
754         je      .Lecb_dec_two
755         movups  0x20($inp),$inout2
756         cmp     \$0x40,$len
757         jb      .Lecb_dec_three
758         movups  0x30($inp),$inout3
759         je      .Lecb_dec_four
760         movups  0x40($inp),$inout4
761         cmp     \$0x60,$len
762         jb      .Lecb_dec_five
763         movups  0x50($inp),$inout5
764         je      .Lecb_dec_six
765         movups  0x60($inp),$inout6
766         $movkey ($key),$rndkey0
767         call    _aesni_decrypt8
768         movups  $inout0,($out)
769         movups  $inout1,0x10($out)
770         movups  $inout2,0x20($out)
771         movups  $inout3,0x30($out)
772         movups  $inout4,0x40($out)
773         movups  $inout5,0x50($out)
774         movups  $inout6,0x60($out)
775         jmp     .Lecb_ret
776 .align  16
777 .Lecb_dec_one:
778 ___
779         &aesni_generate1("dec",$key,$rounds);
780 $code.=<<___;
781         movups  $inout0,($out)
782         jmp     .Lecb_ret
783 .align  16
784 .Lecb_dec_two:
785         xorps   $inout2,$inout2
786         call    _aesni_decrypt3
787         movups  $inout0,($out)
788         movups  $inout1,0x10($out)
789         jmp     .Lecb_ret
790 .align  16
791 .Lecb_dec_three:
792         call    _aesni_decrypt3
793         movups  $inout0,($out)
794         movups  $inout1,0x10($out)
795         movups  $inout2,0x20($out)
796         jmp     .Lecb_ret
797 .align  16
798 .Lecb_dec_four:
799         call    _aesni_decrypt4
800         movups  $inout0,($out)
801         movups  $inout1,0x10($out)
802         movups  $inout2,0x20($out)
803         movups  $inout3,0x30($out)
804         jmp     .Lecb_ret
805 .align  16
806 .Lecb_dec_five:
807         xorps   $inout5,$inout5
808         call    _aesni_decrypt6
809         movups  $inout0,($out)
810         movups  $inout1,0x10($out)
811         movups  $inout2,0x20($out)
812         movups  $inout3,0x30($out)
813         movups  $inout4,0x40($out)
814         jmp     .Lecb_ret
815 .align  16
816 .Lecb_dec_six:
817         call    _aesni_decrypt6
818         movups  $inout0,($out)
819         movups  $inout1,0x10($out)
820         movups  $inout2,0x20($out)
821         movups  $inout3,0x30($out)
822         movups  $inout4,0x40($out)
823         movups  $inout5,0x50($out)
824
825 .Lecb_ret:
826         ret
827 .size   aesni_ecb_encrypt,.-aesni_ecb_encrypt
828 ___
829 \f
830 {
831 ######################################################################
832 # void aesni_ccm64_[en|de]crypt_blocks (const void *in, void *out,
833 #                         size_t blocks, const AES_KEY *key,
834 #                         const char *ivec,char *cmac);
835 #
836 # Handles only complete blocks, operates on 64-bit counter and
837 # does not update *ivec! Nor does it finalize CMAC value
838 # (see engine/eng_aesni.c for details)
839 #
840 {
841 my $cmac="%r9"; # 6th argument
842
843 my $increment="%xmm9";
844 my $iv="%xmm6";
845 my $bswap_mask="%xmm7";
846
847 $code.=<<___;
848 .globl  aesni_ccm64_encrypt_blocks
849 .type   aesni_ccm64_encrypt_blocks,\@function,6
850 .align  16
851 aesni_ccm64_encrypt_blocks:
852 ___
853 $code.=<<___ if ($win64);
854         lea     -0x58(%rsp),%rsp
855         movaps  %xmm6,(%rsp)
856         movaps  %xmm7,0x10(%rsp)
857         movaps  %xmm8,0x20(%rsp)
858         movaps  %xmm9,0x30(%rsp)
859 .Lccm64_enc_body:
860 ___
861 $code.=<<___;
862         mov     240($key),$rounds               # key->rounds
863         movdqu  ($ivp),$iv
864         movdqa  .Lincrement64(%rip),$increment
865         movdqa  .Lbswap_mask(%rip),$bswap_mask
866
867         shl     \$4,$rounds
868         mov     \$16,$rnds_
869         lea     0($key),$key_
870         movdqu  ($cmac),$inout1
871         movdqa  $iv,$inout0
872         lea     32($key,$rounds),$key           # end of key schedule
873         pshufb  $bswap_mask,$iv
874         sub     %rax,%r10                       # twisted $rounds
875         jmp     .Lccm64_enc_outer
876 .align  16
877 .Lccm64_enc_outer:
878         $movkey ($key_),$rndkey0
879         mov     %r10,%rax
880         movups  ($inp),$in0                     # load inp
881
882         xorps   $rndkey0,$inout0                # counter
883         $movkey 16($key_),$rndkey1
884         xorps   $in0,$rndkey0
885         xorps   $rndkey0,$inout1                # cmac^=inp
886         $movkey 32($key_),$rndkey0
887
888 .Lccm64_enc2_loop:
889         aesenc  $rndkey1,$inout0
890         aesenc  $rndkey1,$inout1
891         $movkey ($key,%rax),$rndkey1
892         add     \$32,%rax
893         aesenc  $rndkey0,$inout0
894         aesenc  $rndkey0,$inout1
895         $movkey -16($key,%rax),$rndkey0
896         jnz     .Lccm64_enc2_loop
897         aesenc  $rndkey1,$inout0
898         aesenc  $rndkey1,$inout1
899         paddq   $increment,$iv
900         dec     $len
901         aesenclast      $rndkey0,$inout0
902         aesenclast      $rndkey0,$inout1
903
904         lea     16($inp),$inp
905         xorps   $inout0,$in0                    # inp ^= E(iv)
906         movdqa  $iv,$inout0
907         movups  $in0,($out)                     # save output
908         pshufb  $bswap_mask,$inout0
909         lea     16($out),$out
910         jnz     .Lccm64_enc_outer
911
912         movups  $inout1,($cmac)
913 ___
914 $code.=<<___ if ($win64);
915         movaps  (%rsp),%xmm6
916         movaps  0x10(%rsp),%xmm7
917         movaps  0x20(%rsp),%xmm8
918         movaps  0x30(%rsp),%xmm9
919         lea     0x58(%rsp),%rsp
920 .Lccm64_enc_ret:
921 ___
922 $code.=<<___;
923         ret
924 .size   aesni_ccm64_encrypt_blocks,.-aesni_ccm64_encrypt_blocks
925 ___
926 ######################################################################
927 $code.=<<___;
928 .globl  aesni_ccm64_decrypt_blocks
929 .type   aesni_ccm64_decrypt_blocks,\@function,6
930 .align  16
931 aesni_ccm64_decrypt_blocks:
932 ___
933 $code.=<<___ if ($win64);
934         lea     -0x58(%rsp),%rsp
935         movaps  %xmm6,(%rsp)
936         movaps  %xmm7,0x10(%rsp)
937         movaps  %xmm8,0x20(%rsp)
938         movaps  %xmm9,0x30(%rsp)
939 .Lccm64_dec_body:
940 ___
941 $code.=<<___;
942         mov     240($key),$rounds               # key->rounds
943         movups  ($ivp),$iv
944         movdqu  ($cmac),$inout1
945         movdqa  .Lincrement64(%rip),$increment
946         movdqa  .Lbswap_mask(%rip),$bswap_mask
947
948         movaps  $iv,$inout0
949         mov     $rounds,$rnds_
950         mov     $key,$key_
951         pshufb  $bswap_mask,$iv
952 ___
953         &aesni_generate1("enc",$key,$rounds);
954 $code.=<<___;
955         shl     \$4,$rnds_
956         mov     \$16,$rounds
957         movups  ($inp),$in0                     # load inp
958         paddq   $increment,$iv
959         lea     16($inp),$inp
960         sub     %r10,%rax                       # twisted $rounds
961         lea     32($key_,$rnds_),$key           # end of key schedule
962         mov     %rax,%r10
963         jmp     .Lccm64_dec_outer
964 .align  16
965 .Lccm64_dec_outer:
966         xorps   $inout0,$in0                    # inp ^= E(iv)
967         movdqa  $iv,$inout0
968         movups  $in0,($out)                     # save output
969         lea     16($out),$out
970         pshufb  $bswap_mask,$inout0
971
972         sub     \$1,$len
973         jz      .Lccm64_dec_break
974
975         $movkey ($key_),$rndkey0
976         mov     %r10,%rax
977         $movkey 16($key_),$rndkey1
978         xorps   $rndkey0,$in0
979         xorps   $rndkey0,$inout0
980         xorps   $in0,$inout1                    # cmac^=out
981         $movkey 32($key_),$rndkey0
982         jmp     .Lccm64_dec2_loop
983 .align  16
984 .Lccm64_dec2_loop:
985         aesenc  $rndkey1,$inout0
986         aesenc  $rndkey1,$inout1
987         $movkey ($key,%rax),$rndkey1
988         add     \$32,%rax
989         aesenc  $rndkey0,$inout0
990         aesenc  $rndkey0,$inout1
991         $movkey -16($key,%rax),$rndkey0
992         jnz     .Lccm64_dec2_loop
993         movups  ($inp),$in0                     # load inp
994         paddq   $increment,$iv
995         aesenc  $rndkey1,$inout0
996         aesenc  $rndkey1,$inout1
997         aesenclast      $rndkey0,$inout0
998         aesenclast      $rndkey0,$inout1
999         lea     16($inp),$inp
1000         jmp     .Lccm64_dec_outer
1001
1002 .align  16
1003 .Lccm64_dec_break:
1004         #xorps  $in0,$inout1                    # cmac^=out
1005         mov     240($key_),$rounds
1006 ___
1007         &aesni_generate1("enc",$key_,$rounds,$inout1,$in0);
1008 $code.=<<___;
1009         movups  $inout1,($cmac)
1010 ___
1011 $code.=<<___ if ($win64);
1012         movaps  (%rsp),%xmm6
1013         movaps  0x10(%rsp),%xmm7
1014         movaps  0x20(%rsp),%xmm8
1015         movaps  0x30(%rsp),%xmm9
1016         lea     0x58(%rsp),%rsp
1017 .Lccm64_dec_ret:
1018 ___
1019 $code.=<<___;
1020         ret
1021 .size   aesni_ccm64_decrypt_blocks,.-aesni_ccm64_decrypt_blocks
1022 ___
1023 }\f
1024 ######################################################################
1025 # void aesni_ctr32_encrypt_blocks (const void *in, void *out,
1026 #                         size_t blocks, const AES_KEY *key,
1027 #                         const char *ivec);
1028 #
1029 # Handles only complete blocks, operates on 32-bit counter and
1030 # does not update *ivec! (see crypto/modes/ctr128.c for details)
1031 #
1032 # Overhaul based on suggestions from Shay Gueron and Vlad Krasnov,
1033 # http://rt.openssl.org/Ticket/Display.html?id=3021&user=guest&pass=guest.
1034 # Keywords are full unroll and modulo-schedule counter calculations
1035 # with zero-round key xor.
1036 {
1037 my ($in0,$in1,$in2,$in3,$in4,$in5)=map("%xmm$_",(10..15));
1038 my ($key0,$ctr)=("${key_}d","${ivp}d");
1039 my $frame_size = 0x80 + ($win64?160:0);
1040
1041 $code.=<<___;
1042 .globl  aesni_ctr32_encrypt_blocks
1043 .type   aesni_ctr32_encrypt_blocks,\@function,5
1044 .align  16
1045 aesni_ctr32_encrypt_blocks:
1046         lea     (%rsp),%rax
1047         push    %rbp
1048         sub     \$$frame_size,%rsp
1049         and     \$-16,%rsp      # Linux kernel stack can be incorrectly seeded
1050 ___
1051 $code.=<<___ if ($win64);
1052         movaps  %xmm6,-0xa8(%rax)
1053         movaps  %xmm7,-0x98(%rax)
1054         movaps  %xmm8,-0x88(%rax)
1055         movaps  %xmm9,-0x78(%rax)
1056         movaps  %xmm10,-0x68(%rax)
1057         movaps  %xmm11,-0x58(%rax)
1058         movaps  %xmm12,-0x48(%rax)
1059         movaps  %xmm13,-0x38(%rax)
1060         movaps  %xmm14,-0x28(%rax)
1061         movaps  %xmm15,-0x18(%rax)
1062 .Lctr32_body:
1063 ___
1064 $code.=<<___;
1065         lea     -8(%rax),%rbp
1066
1067         cmp     \$1,$len
1068         je      .Lctr32_one_shortcut
1069
1070         movdqu  ($ivp),$inout0
1071         movdqu  ($key),$rndkey0
1072         mov     12($ivp),$ctr                   # counter LSB
1073         pxor    $rndkey0,$inout0
1074         mov     12($key),$key0                  # 0-round key LSB
1075         movdqa  $inout0,0x00(%rsp)              # populate counter block
1076         bswap   $ctr
1077         movdqa  $inout0,$inout1
1078         movdqa  $inout0,$inout2
1079         movdqa  $inout0,$inout3
1080         movdqa  $inout0,0x40(%rsp)
1081         movdqa  $inout0,0x50(%rsp)
1082         movdqa  $inout0,0x60(%rsp)
1083         mov     %rdx,%r10                       # borrow %rdx
1084         movdqa  $inout0,0x70(%rsp)
1085
1086         lea     1($ctr),%rax
1087          lea    2($ctr),%rdx
1088         bswap   %eax
1089          bswap  %edx
1090         xor     $key0,%eax
1091          xor    $key0,%edx
1092         pinsrd  \$3,%eax,$inout1
1093         lea     3($ctr),%rax
1094         movdqa  $inout1,0x10(%rsp)
1095          pinsrd \$3,%edx,$inout2
1096         bswap   %eax
1097          mov    %r10,%rdx                       # restore %rdx
1098          lea    4($ctr),%r10
1099          movdqa $inout2,0x20(%rsp)
1100         xor     $key0,%eax
1101          bswap  %r10d
1102         pinsrd  \$3,%eax,$inout3
1103          xor    $key0,%r10d
1104         movdqa  $inout3,0x30(%rsp)
1105         lea     5($ctr),%r9
1106          mov    %r10d,0x40+12(%rsp)
1107         bswap   %r9d
1108          lea    6($ctr),%r10
1109         mov     240($key),$rounds               # key->rounds
1110         xor     $key0,%r9d
1111          bswap  %r10d
1112         mov     %r9d,0x50+12(%rsp)
1113          xor    $key0,%r10d
1114         lea     7($ctr),%r9
1115          mov    %r10d,0x60+12(%rsp)
1116         bswap   %r9d
1117          mov    OPENSSL_ia32cap_P+4(%rip),%r10d 
1118         xor     $key0,%r9d
1119          and    \$`1<<26|1<<22`,%r10d           # isolate XSAVE+MOVBE
1120         mov     %r9d,0x70+12(%rsp)
1121
1122         $movkey 0x10($key),$rndkey1
1123
1124         movdqa  0x40(%rsp),$inout4
1125         movdqa  0x50(%rsp),$inout5
1126
1127         cmp     \$8,$len
1128         jb      .Lctr32_tail
1129
1130         sub     \$6,$len
1131         cmp     \$`1<<22`,%r10d         # check for MOVBE without XSAVE
1132         je      .Lctr32_6x
1133
1134         lea     0x80($key),$key         # size optimization
1135         sub     \$2,$len
1136         jmp     .Lctr32_loop8
1137
1138 .align  16
1139 .Lctr32_6x:
1140         shl     \$4,$rounds
1141         mov     \$48,$rnds_
1142         bswap   $key0
1143         lea     32($key,$rounds),$key   # end of key schedule
1144         sub     %rax,%r10               # twisted $rounds
1145         jmp     .Lctr32_loop6
1146
1147 .align  16
1148 .Lctr32_loop6:
1149          add    \$6,$ctr
1150         $movkey -48($key,$rnds_),$rndkey0
1151         aesenc  $rndkey1,$inout0
1152          mov    $ctr,%eax
1153          xor    $key0,%eax
1154         aesenc  $rndkey1,$inout1
1155          movbe  %eax,`0x00+12`(%rsp)
1156          lea    1($ctr),%eax
1157         aesenc  $rndkey1,$inout2
1158          xor    $key0,%eax
1159          movbe  %eax,`0x10+12`(%rsp)
1160         aesenc  $rndkey1,$inout3
1161          lea    2($ctr),%eax
1162          xor    $key0,%eax
1163         aesenc  $rndkey1,$inout4
1164          movbe  %eax,`0x20+12`(%rsp)
1165          lea    3($ctr),%eax
1166         aesenc  $rndkey1,$inout5
1167         $movkey -32($key,$rnds_),$rndkey1
1168          xor    $key0,%eax
1169
1170         aesenc  $rndkey0,$inout0
1171          movbe  %eax,`0x30+12`(%rsp)
1172          lea    4($ctr),%eax
1173         aesenc  $rndkey0,$inout1
1174          xor    $key0,%eax
1175          movbe  %eax,`0x40+12`(%rsp)
1176         aesenc  $rndkey0,$inout2
1177          lea    5($ctr),%eax
1178          xor    $key0,%eax
1179         aesenc  $rndkey0,$inout3
1180          movbe  %eax,`0x50+12`(%rsp)
1181          mov    %r10,%rax               # mov   $rnds_,$rounds
1182         aesenc  $rndkey0,$inout4
1183         aesenc  $rndkey0,$inout5
1184         $movkey -16($key,$rnds_),$rndkey0
1185
1186         call    .Lenc_loop6
1187
1188         movdqu  ($inp),$inout6
1189         movdqu  0x10($inp),$inout7
1190         movdqu  0x20($inp),$in0
1191         movdqu  0x30($inp),$in1
1192         movdqu  0x40($inp),$in2
1193         movdqu  0x50($inp),$in3
1194         lea     0x60($inp),$inp
1195         $movkey -64($key,$rnds_),$rndkey1
1196         pxor    $inout0,$inout6
1197         movaps  0x00(%rsp),$inout0
1198         pxor    $inout1,$inout7
1199         movaps  0x10(%rsp),$inout1
1200         pxor    $inout2,$in0
1201         movaps  0x20(%rsp),$inout2
1202         pxor    $inout3,$in1
1203         movaps  0x30(%rsp),$inout3
1204         pxor    $inout4,$in2
1205         movaps  0x40(%rsp),$inout4
1206         pxor    $inout5,$in3
1207         movaps  0x50(%rsp),$inout5
1208         movdqu  $inout6,($out)
1209         movdqu  $inout7,0x10($out)
1210         movdqu  $in0,0x20($out)
1211         movdqu  $in1,0x30($out)
1212         movdqu  $in2,0x40($out)
1213         movdqu  $in3,0x50($out)
1214         lea     0x60($out),$out
1215         
1216         sub     \$6,$len
1217         jnc     .Lctr32_loop6
1218
1219         add     \$6,$len
1220         jz      .Lctr32_done
1221
1222         lea     -48($rnds_),$rounds
1223         lea     -80($key,$rnds_),$key   # restore $key
1224         neg     $rounds
1225         shr     \$4,$rounds             # restore $rounds
1226         jmp     .Lctr32_tail
1227
1228 .align  32
1229 .Lctr32_loop8:
1230          add            \$8,$ctr
1231         movdqa          0x60(%rsp),$inout6
1232         aesenc          $rndkey1,$inout0
1233          mov            $ctr,%r9d
1234         movdqa          0x70(%rsp),$inout7
1235         aesenc          $rndkey1,$inout1
1236          bswap          %r9d
1237         $movkey         0x20-0x80($key),$rndkey0
1238         aesenc          $rndkey1,$inout2
1239          xor            $key0,%r9d
1240          nop
1241         aesenc          $rndkey1,$inout3
1242          mov            %r9d,0x00+12(%rsp)
1243          lea            1($ctr),%r9
1244         aesenc          $rndkey1,$inout4
1245         aesenc          $rndkey1,$inout5
1246         aesenc          $rndkey1,$inout6
1247         aesenc          $rndkey1,$inout7
1248         $movkey         0x30-0x80($key),$rndkey1
1249 ___
1250 for($i=2;$i<8;$i++) {
1251 my $rndkeyx = ($i&1)?$rndkey1:$rndkey0;
1252 $code.=<<___;
1253          bswap          %r9d
1254         aesenc          $rndkeyx,$inout0
1255         aesenc          $rndkeyx,$inout1
1256          xor            $key0,%r9d
1257          .byte          0x66,0x90
1258         aesenc          $rndkeyx,$inout2
1259         aesenc          $rndkeyx,$inout3
1260          mov            %r9d,`0x10*($i-1)`+12(%rsp)
1261          lea            $i($ctr),%r9
1262         aesenc          $rndkeyx,$inout4
1263         aesenc          $rndkeyx,$inout5
1264         aesenc          $rndkeyx,$inout6
1265         aesenc          $rndkeyx,$inout7
1266         $movkey         `0x20+0x10*$i`-0x80($key),$rndkeyx
1267 ___
1268 }
1269 $code.=<<___;
1270          bswap          %r9d
1271         aesenc          $rndkey0,$inout0
1272         aesenc          $rndkey0,$inout1
1273         aesenc          $rndkey0,$inout2
1274          xor            $key0,%r9d
1275          movdqu         0x00($inp),$in0
1276         aesenc          $rndkey0,$inout3
1277          mov            %r9d,0x70+12(%rsp)
1278          cmp            \$11,$rounds
1279         aesenc          $rndkey0,$inout4
1280         aesenc          $rndkey0,$inout5
1281         aesenc          $rndkey0,$inout6
1282         aesenc          $rndkey0,$inout7
1283         $movkey         0xa0-0x80($key),$rndkey0
1284
1285         jb              .Lctr32_enc_done
1286
1287         aesenc          $rndkey1,$inout0
1288         aesenc          $rndkey1,$inout1
1289         aesenc          $rndkey1,$inout2
1290         aesenc          $rndkey1,$inout3
1291         aesenc          $rndkey1,$inout4
1292         aesenc          $rndkey1,$inout5
1293         aesenc          $rndkey1,$inout6
1294         aesenc          $rndkey1,$inout7
1295         $movkey         0xb0-0x80($key),$rndkey1
1296
1297         aesenc          $rndkey0,$inout0
1298         aesenc          $rndkey0,$inout1
1299         aesenc          $rndkey0,$inout2
1300         aesenc          $rndkey0,$inout3
1301         aesenc          $rndkey0,$inout4
1302         aesenc          $rndkey0,$inout5
1303         aesenc          $rndkey0,$inout6
1304         aesenc          $rndkey0,$inout7
1305         $movkey         0xc0-0x80($key),$rndkey0
1306         je              .Lctr32_enc_done
1307
1308         aesenc          $rndkey1,$inout0
1309         aesenc          $rndkey1,$inout1
1310         aesenc          $rndkey1,$inout2
1311         aesenc          $rndkey1,$inout3
1312         aesenc          $rndkey1,$inout4
1313         aesenc          $rndkey1,$inout5
1314         aesenc          $rndkey1,$inout6
1315         aesenc          $rndkey1,$inout7
1316         $movkey         0xd0-0x80($key),$rndkey1
1317
1318         aesenc          $rndkey0,$inout0
1319         aesenc          $rndkey0,$inout1
1320         aesenc          $rndkey0,$inout2
1321         aesenc          $rndkey0,$inout3
1322         aesenc          $rndkey0,$inout4
1323         aesenc          $rndkey0,$inout5
1324         aesenc          $rndkey0,$inout6
1325         aesenc          $rndkey0,$inout7
1326         $movkey         0xe0-0x80($key),$rndkey0
1327         jmp             .Lctr32_enc_done
1328
1329 .align  16
1330 .Lctr32_enc_done:
1331         movdqu          0x10($inp),$in1
1332         pxor            $rndkey0,$in0
1333         movdqu          0x20($inp),$in2
1334         pxor            $rndkey0,$in1
1335         movdqu          0x30($inp),$in3
1336         pxor            $rndkey0,$in2
1337         movdqu          0x40($inp),$in4
1338         pxor            $rndkey0,$in3
1339         movdqu          0x50($inp),$in5
1340         pxor            $rndkey0,$in4
1341         pxor            $rndkey0,$in5
1342         aesenc          $rndkey1,$inout0
1343         aesenc          $rndkey1,$inout1
1344         aesenc          $rndkey1,$inout2
1345         aesenc          $rndkey1,$inout3
1346         aesenc          $rndkey1,$inout4
1347         aesenc          $rndkey1,$inout5
1348         aesenc          $rndkey1,$inout6
1349         aesenc          $rndkey1,$inout7
1350         movdqu          0x60($inp),$rndkey1
1351         lea             0x80($inp),$inp
1352
1353         aesenclast      $in0,$inout0
1354         pxor            $rndkey0,$rndkey1
1355         movdqu          0x70-0x80($inp),$in0
1356         aesenclast      $in1,$inout1
1357         pxor            $rndkey0,$in0
1358         movdqa          0x00(%rsp),$in1         # load next counter block
1359         aesenclast      $in2,$inout2
1360         aesenclast      $in3,$inout3
1361         movdqa          0x10(%rsp),$in2
1362         movdqa          0x20(%rsp),$in3
1363         aesenclast      $in4,$inout4
1364         aesenclast      $in5,$inout5
1365         movdqa          0x30(%rsp),$in4
1366         movdqa          0x40(%rsp),$in5
1367         aesenclast      $rndkey1,$inout6
1368         movdqa          0x50(%rsp),$rndkey0
1369         $movkey         0x10-0x80($key),$rndkey1
1370         aesenclast      $in0,$inout7
1371
1372         movups          $inout0,($out)          # store output
1373         movdqa          $in1,$inout0
1374         movups          $inout1,0x10($out)
1375         movdqa          $in2,$inout1
1376         movups          $inout2,0x20($out)
1377         movdqa          $in3,$inout2
1378         movups          $inout3,0x30($out)
1379         movdqa          $in4,$inout3
1380         movups          $inout4,0x40($out)
1381         movdqa          $in5,$inout4
1382         movups          $inout5,0x50($out)
1383         movdqa          $rndkey0,$inout5
1384         movups          $inout6,0x60($out)
1385         movups          $inout7,0x70($out)
1386         lea             0x80($out),$out
1387         
1388         sub     \$8,$len
1389         jnc     .Lctr32_loop8
1390
1391         add     \$8,$len
1392         jz      .Lctr32_done
1393         lea     -0x80($key),$key
1394
1395 .Lctr32_tail:
1396         lea     16($key),$key
1397         cmp     \$4,$len
1398         jb      .Lctr32_loop3
1399         je      .Lctr32_loop4
1400
1401         shl             \$4,$rounds
1402         movdqa          0x60(%rsp),$inout6
1403         pxor            $inout7,$inout7
1404
1405         $movkey         16($key),$rndkey0
1406         aesenc          $rndkey1,$inout0
1407         aesenc          $rndkey1,$inout1
1408         lea             32-16($key,$rounds),$key
1409         neg             %rax
1410         aesenc          $rndkey1,$inout2
1411         add             \$16,%rax
1412          movups         ($inp),$in0
1413         aesenc          $rndkey1,$inout3
1414         aesenc          $rndkey1,$inout4
1415          movups         0x10($inp),$in1
1416          movups         0x20($inp),$in2
1417         aesenc          $rndkey1,$inout5
1418         aesenc          $rndkey1,$inout6
1419
1420         call            .Lenc_loop8_enter
1421
1422         movdqu  0x30($inp),$in3
1423         pxor    $in0,$inout0
1424         movdqu  0x40($inp),$in0
1425         pxor    $in1,$inout1
1426         movdqu  $inout0,($out)
1427         pxor    $in2,$inout2
1428         movdqu  $inout1,0x10($out)
1429         pxor    $in3,$inout3
1430         movdqu  $inout2,0x20($out)
1431         pxor    $in0,$inout4
1432         movdqu  $inout3,0x30($out)
1433         movdqu  $inout4,0x40($out)
1434         cmp     \$6,$len
1435         jb      .Lctr32_done
1436
1437         movups  0x50($inp),$in1
1438         xorps   $in1,$inout5
1439         movups  $inout5,0x50($out)
1440         je      .Lctr32_done
1441
1442         movups  0x60($inp),$in2
1443         xorps   $in2,$inout6
1444         movups  $inout6,0x60($out)
1445         jmp     .Lctr32_done
1446
1447 .align  32
1448 .Lctr32_loop4:
1449         aesenc          $rndkey1,$inout0
1450         lea             16($key),$key
1451         dec             $rounds
1452         aesenc          $rndkey1,$inout1
1453         aesenc          $rndkey1,$inout2
1454         aesenc          $rndkey1,$inout3
1455         $movkey         ($key),$rndkey1
1456         jnz             .Lctr32_loop4
1457         aesenclast      $rndkey1,$inout0
1458         aesenclast      $rndkey1,$inout1
1459          movups         ($inp),$in0
1460          movups         0x10($inp),$in1
1461         aesenclast      $rndkey1,$inout2
1462         aesenclast      $rndkey1,$inout3
1463          movups         0x20($inp),$in2
1464          movups         0x30($inp),$in3
1465
1466         xorps   $in0,$inout0
1467         movups  $inout0,($out)
1468         xorps   $in1,$inout1
1469         movups  $inout1,0x10($out)
1470         pxor    $in2,$inout2
1471         movdqu  $inout2,0x20($out)
1472         pxor    $in3,$inout3
1473         movdqu  $inout3,0x30($out)
1474         jmp     .Lctr32_done
1475
1476 .align  32
1477 .Lctr32_loop3:
1478         aesenc          $rndkey1,$inout0
1479         lea             16($key),$key
1480         dec             $rounds
1481         aesenc          $rndkey1,$inout1
1482         aesenc          $rndkey1,$inout2
1483         $movkey         ($key),$rndkey1
1484         jnz             .Lctr32_loop3
1485         aesenclast      $rndkey1,$inout0
1486         aesenclast      $rndkey1,$inout1
1487         aesenclast      $rndkey1,$inout2
1488
1489         movups  ($inp),$in0
1490         xorps   $in0,$inout0
1491         movups  $inout0,($out)
1492         cmp     \$2,$len
1493         jb      .Lctr32_done
1494
1495         movups  0x10($inp),$in1
1496         xorps   $in1,$inout1
1497         movups  $inout1,0x10($out)
1498         je      .Lctr32_done
1499
1500         movups  0x20($inp),$in2
1501         xorps   $in2,$inout2
1502         movups  $inout2,0x20($out)
1503         jmp     .Lctr32_done
1504
1505 .align  16
1506 .Lctr32_one_shortcut:
1507         movups  ($ivp),$inout0
1508         movups  ($inp),$in0
1509         mov     240($key),$rounds               # key->rounds
1510 ___
1511         &aesni_generate1("enc",$key,$rounds);
1512 $code.=<<___;
1513         xorps   $in0,$inout0
1514         movups  $inout0,($out)
1515         jmp     .Lctr32_done
1516
1517 .align  16
1518 .Lctr32_done:
1519 ___
1520 $code.=<<___ if ($win64);
1521         movaps  -0xa0(%rbp),%xmm6
1522         movaps  -0x90(%rbp),%xmm7
1523         movaps  -0x80(%rbp),%xmm8
1524         movaps  -0x70(%rbp),%xmm9
1525         movaps  -0x60(%rbp),%xmm10
1526         movaps  -0x50(%rbp),%xmm11
1527         movaps  -0x40(%rbp),%xmm12
1528         movaps  -0x30(%rbp),%xmm13
1529         movaps  -0x20(%rbp),%xmm14
1530         movaps  -0x10(%rbp),%xmm15
1531 ___
1532 $code.=<<___;
1533         lea     (%rbp),%rsp
1534         pop     %rbp
1535 .Lctr32_epilogue:
1536         ret
1537 .size   aesni_ctr32_encrypt_blocks,.-aesni_ctr32_encrypt_blocks
1538 ___
1539 }
1540 \f
1541 ######################################################################
1542 # void aesni_xts_[en|de]crypt(const char *inp,char *out,size_t len,
1543 #       const AES_KEY *key1, const AES_KEY *key2
1544 #       const unsigned char iv[16]);
1545 #
1546 {
1547 my @tweak=map("%xmm$_",(10..15));
1548 my ($twmask,$twres,$twtmp)=("%xmm8","%xmm9",@tweak[4]);
1549 my ($key2,$ivp,$len_)=("%r8","%r9","%r9");
1550 my $frame_size = 0x70 + ($win64?160:0);
1551
1552 $code.=<<___;
1553 .globl  aesni_xts_encrypt
1554 .type   aesni_xts_encrypt,\@function,6
1555 .align  16
1556 aesni_xts_encrypt:
1557         lea     (%rsp),%rax
1558         push    %rbp
1559         sub     \$$frame_size,%rsp
1560         and     \$-16,%rsp      # Linux kernel stack can be incorrectly seeded
1561 ___
1562 $code.=<<___ if ($win64);
1563         movaps  %xmm6,-0xa8(%rax)
1564         movaps  %xmm7,-0x98(%rax)
1565         movaps  %xmm8,-0x88(%rax)
1566         movaps  %xmm9,-0x78(%rax)
1567         movaps  %xmm10,-0x68(%rax)
1568         movaps  %xmm11,-0x58(%rax)
1569         movaps  %xmm12,-0x48(%rax)
1570         movaps  %xmm13,-0x38(%rax)
1571         movaps  %xmm14,-0x28(%rax)
1572         movaps  %xmm15,-0x18(%rax)
1573 .Lxts_enc_body:
1574 ___
1575 $code.=<<___;
1576         lea     -8(%rax),%rbp
1577         movups  ($ivp),$inout0                  # load clear-text tweak
1578         mov     240(%r8),$rounds                # key2->rounds
1579         mov     240($key),$rnds_                # key1->rounds
1580 ___
1581         # generate the tweak
1582         &aesni_generate1("enc",$key2,$rounds,$inout0);
1583 $code.=<<___;
1584         $movkey ($key),$rndkey0                 # zero round key
1585         mov     $key,$key_                      # backup $key
1586         mov     $rnds_,$rounds                  # backup $rounds
1587         shl     \$4,$rnds_
1588         mov     $len,$len_                      # backup $len
1589         and     \$-16,$len
1590
1591         $movkey 16($key,$rnds_),$rndkey1        # last round key
1592
1593         movdqa  .Lxts_magic(%rip),$twmask
1594         movdqa  $inout0,@tweak[5]
1595         pshufd  \$0x5f,$inout0,$twres
1596         pxor    $rndkey0,$rndkey1
1597 ___
1598     # alternative tweak calculation algorithm is based on suggestions
1599     # by Shay Gueron. psrad doesn't conflict with AES-NI instructions
1600     # and should help in the future...
1601     for ($i=0;$i<4;$i++) {
1602     $code.=<<___;
1603         movdqa  $twres,$twtmp
1604         paddd   $twres,$twres
1605         movdqa  @tweak[5],@tweak[$i]
1606         psrad   \$31,$twtmp                     # broadcast upper bits
1607         paddq   @tweak[5],@tweak[5]
1608         pand    $twmask,$twtmp
1609         pxor    $rndkey0,@tweak[$i]
1610         pxor    $twtmp,@tweak[5]
1611 ___
1612     }
1613 $code.=<<___;
1614         movdqa  @tweak[5],@tweak[4]
1615         psrad   \$31,$twres
1616         paddq   @tweak[5],@tweak[5]
1617         pand    $twmask,$twres
1618         pxor    $rndkey0,@tweak[4]
1619         pxor    $twres,@tweak[5]
1620         movaps  $rndkey1,0x60(%rsp)             # save round[0]^round[last]
1621
1622         sub     \$16*6,$len
1623         jc      .Lxts_enc_short
1624
1625         mov     \$16+96,$rounds
1626         lea     32($key_,$rnds_),$key           # end of key schedule
1627         sub     %r10,%rax                       # twisted $rounds
1628         $movkey 16($key_),$rndkey1
1629         mov     %rax,%r10                       # backup twisted $rounds
1630         lea     .Lxts_magic(%rip),%r8
1631         jmp     .Lxts_enc_grandloop
1632
1633 .align  32
1634 .Lxts_enc_grandloop:
1635         movdqu  `16*0`($inp),$inout0            # load input
1636         movdqa  $rndkey0,$twmask
1637         movdqu  `16*1`($inp),$inout1
1638         pxor    @tweak[0],$inout0
1639         movdqu  `16*2`($inp),$inout2
1640         pxor    @tweak[1],$inout1
1641          aesenc         $rndkey1,$inout0
1642         movdqu  `16*3`($inp),$inout3
1643         pxor    @tweak[2],$inout2
1644          aesenc         $rndkey1,$inout1
1645         movdqu  `16*4`($inp),$inout4
1646         pxor    @tweak[3],$inout3
1647          aesenc         $rndkey1,$inout2
1648         movdqu  `16*5`($inp),$inout5
1649         pxor    @tweak[5],$twmask               # round[0]^=tweak[5]
1650          movdqa 0x60(%rsp),$twres               # load round[0]^round[last]
1651         pxor    @tweak[4],$inout4
1652          aesenc         $rndkey1,$inout3
1653         $movkey 32($key_),$rndkey0
1654         lea     `16*6`($inp),$inp
1655         pxor    $twmask,$inout5
1656
1657          pxor   $twres,@tweak[0]
1658         aesenc          $rndkey1,$inout4
1659          pxor   $twres,@tweak[1]
1660          movdqa @tweak[0],`16*0`(%rsp)          # put aside tweaks^last round key
1661         aesenc          $rndkey1,$inout5
1662         $movkey         48($key_),$rndkey1
1663          pxor   $twres,@tweak[2]
1664
1665         aesenc          $rndkey0,$inout0
1666          pxor   $twres,@tweak[3]
1667          movdqa @tweak[1],`16*1`(%rsp)
1668         aesenc          $rndkey0,$inout1
1669          pxor   $twres,@tweak[4]
1670          movdqa @tweak[2],`16*2`(%rsp)
1671         aesenc          $rndkey0,$inout2
1672         aesenc          $rndkey0,$inout3
1673          pxor   $twres,$twmask
1674          movdqa @tweak[4],`16*4`(%rsp)
1675         aesenc          $rndkey0,$inout4
1676         aesenc          $rndkey0,$inout5
1677         $movkey         64($key_),$rndkey0
1678          movdqa $twmask,`16*5`(%rsp)
1679         pshufd  \$0x5f,@tweak[5],$twres
1680         jmp     .Lxts_enc_loop6
1681 .align  32
1682 .Lxts_enc_loop6:
1683         aesenc          $rndkey1,$inout0
1684         aesenc          $rndkey1,$inout1
1685         aesenc          $rndkey1,$inout2
1686         aesenc          $rndkey1,$inout3
1687         aesenc          $rndkey1,$inout4
1688         aesenc          $rndkey1,$inout5
1689         $movkey         -64($key,%rax),$rndkey1
1690         add             \$32,%rax
1691
1692         aesenc          $rndkey0,$inout0
1693         aesenc          $rndkey0,$inout1
1694         aesenc          $rndkey0,$inout2
1695         aesenc          $rndkey0,$inout3
1696         aesenc          $rndkey0,$inout4
1697         aesenc          $rndkey0,$inout5
1698         $movkey         -80($key,%rax),$rndkey0
1699         jnz             .Lxts_enc_loop6
1700
1701         movdqa  (%r8),$twmask
1702         movdqa  $twres,$twtmp
1703         paddd   $twres,$twres
1704          aesenc         $rndkey1,$inout0
1705         paddq   @tweak[5],@tweak[5]
1706         psrad   \$31,$twtmp
1707          aesenc         $rndkey1,$inout1
1708         pand    $twmask,$twtmp
1709         $movkey ($key_),@tweak[0]               # load round[0]
1710          aesenc         $rndkey1,$inout2
1711          aesenc         $rndkey1,$inout3
1712          aesenc         $rndkey1,$inout4
1713         pxor    $twtmp,@tweak[5]
1714         movaps  @tweak[0],@tweak[1]             # copy round[0]
1715          aesenc         $rndkey1,$inout5
1716          $movkey        -64($key),$rndkey1
1717
1718         movdqa  $twres,$twtmp
1719          aesenc         $rndkey0,$inout0
1720         paddd   $twres,$twres
1721         pxor    @tweak[5],@tweak[0]
1722          aesenc         $rndkey0,$inout1
1723         psrad   \$31,$twtmp
1724         paddq   @tweak[5],@tweak[5]
1725          aesenc         $rndkey0,$inout2
1726          aesenc         $rndkey0,$inout3
1727         pand    $twmask,$twtmp
1728         movaps  @tweak[1],@tweak[2]
1729          aesenc         $rndkey0,$inout4
1730         pxor    $twtmp,@tweak[5]
1731         movdqa  $twres,$twtmp
1732          aesenc         $rndkey0,$inout5
1733          $movkey        -48($key),$rndkey0
1734
1735         paddd   $twres,$twres
1736          aesenc         $rndkey1,$inout0
1737         pxor    @tweak[5],@tweak[1]
1738         psrad   \$31,$twtmp
1739          aesenc         $rndkey1,$inout1
1740         paddq   @tweak[5],@tweak[5]
1741         pand    $twmask,$twtmp
1742          aesenc         $rndkey1,$inout2
1743          aesenc         $rndkey1,$inout3
1744          movdqa @tweak[3],`16*3`(%rsp)
1745         pxor    $twtmp,@tweak[5]
1746          aesenc         $rndkey1,$inout4
1747         movaps  @tweak[2],@tweak[3]
1748         movdqa  $twres,$twtmp
1749          aesenc         $rndkey1,$inout5
1750          $movkey        -32($key),$rndkey1
1751
1752         paddd   $twres,$twres
1753          aesenc         $rndkey0,$inout0
1754         pxor    @tweak[5],@tweak[2]
1755         psrad   \$31,$twtmp
1756          aesenc         $rndkey0,$inout1
1757         paddq   @tweak[5],@tweak[5]
1758         pand    $twmask,$twtmp
1759          aesenc         $rndkey0,$inout2
1760          aesenc         $rndkey0,$inout3
1761          aesenc         $rndkey0,$inout4
1762         pxor    $twtmp,@tweak[5]
1763         movaps  @tweak[3],@tweak[4]
1764          aesenc         $rndkey0,$inout5
1765
1766         movdqa  $twres,$rndkey0
1767         paddd   $twres,$twres
1768          aesenc         $rndkey1,$inout0
1769         pxor    @tweak[5],@tweak[3]
1770         psrad   \$31,$rndkey0
1771          aesenc         $rndkey1,$inout1
1772         paddq   @tweak[5],@tweak[5]
1773         pand    $twmask,$rndkey0
1774          aesenc         $rndkey1,$inout2
1775          aesenc         $rndkey1,$inout3
1776         pxor    $rndkey0,@tweak[5]
1777         $movkey         ($key_),$rndkey0
1778          aesenc         $rndkey1,$inout4
1779          aesenc         $rndkey1,$inout5
1780         $movkey         16($key_),$rndkey1
1781
1782         pxor    @tweak[5],@tweak[4]
1783          aesenclast     `16*0`(%rsp),$inout0
1784         psrad   \$31,$twres
1785         paddq   @tweak[5],@tweak[5]
1786          aesenclast     `16*1`(%rsp),$inout1
1787          aesenclast     `16*2`(%rsp),$inout2
1788         pand    $twmask,$twres
1789         mov     %r10,%rax                       # restore $rounds
1790          aesenclast     `16*3`(%rsp),$inout3
1791          aesenclast     `16*4`(%rsp),$inout4
1792          aesenclast     `16*5`(%rsp),$inout5
1793         pxor    $twres,@tweak[5]
1794
1795         lea     `16*6`($out),$out
1796         movups  $inout0,`-16*6`($out)           # write output
1797         movups  $inout1,`-16*5`($out)
1798         movups  $inout2,`-16*4`($out)
1799         movups  $inout3,`-16*3`($out)
1800         movups  $inout4,`-16*2`($out)
1801         movups  $inout5,`-16*1`($out)
1802         sub     \$16*6,$len
1803         jnc     .Lxts_enc_grandloop
1804
1805         mov     \$16+96,$rounds
1806         sub     $rnds_,$rounds
1807         mov     $key_,$key                      # restore $key
1808         shr     \$4,$rounds                     # restore original value
1809
1810 .Lxts_enc_short:
1811         mov     $rounds,$rnds_                  # backup $rounds
1812         pxor    $rndkey0,@tweak[0]
1813         add     \$16*6,$len
1814         jz      .Lxts_enc_done
1815
1816         pxor    $rndkey0,@tweak[1]
1817         cmp     \$0x20,$len
1818         jb      .Lxts_enc_one
1819         pxor    $rndkey0,@tweak[2]
1820         je      .Lxts_enc_two
1821
1822         pxor    $rndkey0,@tweak[3]
1823         cmp     \$0x40,$len
1824         jb      .Lxts_enc_three
1825         pxor    $rndkey0,@tweak[4]
1826         je      .Lxts_enc_four
1827
1828         movdqu  ($inp),$inout0
1829         movdqu  16*1($inp),$inout1
1830         movdqu  16*2($inp),$inout2
1831         pxor    @tweak[0],$inout0
1832         movdqu  16*3($inp),$inout3
1833         pxor    @tweak[1],$inout1
1834         movdqu  16*4($inp),$inout4
1835         lea     16*5($inp),$inp
1836         pxor    @tweak[2],$inout2
1837         pxor    @tweak[3],$inout3
1838         pxor    @tweak[4],$inout4
1839
1840         call    _aesni_encrypt6
1841
1842         xorps   @tweak[0],$inout0
1843         movdqa  @tweak[5],@tweak[0]
1844         xorps   @tweak[1],$inout1
1845         xorps   @tweak[2],$inout2
1846         movdqu  $inout0,($out)
1847         xorps   @tweak[3],$inout3
1848         movdqu  $inout1,16*1($out)
1849         xorps   @tweak[4],$inout4
1850         movdqu  $inout2,16*2($out)
1851         movdqu  $inout3,16*3($out)
1852         movdqu  $inout4,16*4($out)
1853         lea     16*5($out),$out
1854         jmp     .Lxts_enc_done
1855
1856 .align  16
1857 .Lxts_enc_one:
1858         movups  ($inp),$inout0
1859         lea     16*1($inp),$inp
1860         xorps   @tweak[0],$inout0
1861 ___
1862         &aesni_generate1("enc",$key,$rounds);
1863 $code.=<<___;
1864         xorps   @tweak[0],$inout0
1865         movdqa  @tweak[1],@tweak[0]
1866         movups  $inout0,($out)
1867         lea     16*1($out),$out
1868         jmp     .Lxts_enc_done
1869
1870 .align  16
1871 .Lxts_enc_two:
1872         movups  ($inp),$inout0
1873         movups  16($inp),$inout1
1874         lea     32($inp),$inp
1875         xorps   @tweak[0],$inout0
1876         xorps   @tweak[1],$inout1
1877
1878         call    _aesni_encrypt3
1879
1880         xorps   @tweak[0],$inout0
1881         movdqa  @tweak[2],@tweak[0]
1882         xorps   @tweak[1],$inout1
1883         movups  $inout0,($out)
1884         movups  $inout1,16*1($out)
1885         lea     16*2($out),$out
1886         jmp     .Lxts_enc_done
1887
1888 .align  16
1889 .Lxts_enc_three:
1890         movups  ($inp),$inout0
1891         movups  16*1($inp),$inout1
1892         movups  16*2($inp),$inout2
1893         lea     16*3($inp),$inp
1894         xorps   @tweak[0],$inout0
1895         xorps   @tweak[1],$inout1
1896         xorps   @tweak[2],$inout2
1897
1898         call    _aesni_encrypt3
1899
1900         xorps   @tweak[0],$inout0
1901         movdqa  @tweak[3],@tweak[0]
1902         xorps   @tweak[1],$inout1
1903         xorps   @tweak[2],$inout2
1904         movups  $inout0,($out)
1905         movups  $inout1,16*1($out)
1906         movups  $inout2,16*2($out)
1907         lea     16*3($out),$out
1908         jmp     .Lxts_enc_done
1909
1910 .align  16
1911 .Lxts_enc_four:
1912         movups  ($inp),$inout0
1913         movups  16*1($inp),$inout1
1914         movups  16*2($inp),$inout2
1915         xorps   @tweak[0],$inout0
1916         movups  16*3($inp),$inout3
1917         lea     16*4($inp),$inp
1918         xorps   @tweak[1],$inout1
1919         xorps   @tweak[2],$inout2
1920         xorps   @tweak[3],$inout3
1921
1922         call    _aesni_encrypt4
1923
1924         pxor    @tweak[0],$inout0
1925         movdqa  @tweak[4],@tweak[0]
1926         pxor    @tweak[1],$inout1
1927         pxor    @tweak[2],$inout2
1928         movdqu  $inout0,($out)
1929         pxor    @tweak[3],$inout3
1930         movdqu  $inout1,16*1($out)
1931         movdqu  $inout2,16*2($out)
1932         movdqu  $inout3,16*3($out)
1933         lea     16*4($out),$out
1934         jmp     .Lxts_enc_done
1935
1936 .align  16
1937 .Lxts_enc_done:
1938         and     \$15,$len_
1939         jz      .Lxts_enc_ret
1940         mov     $len_,$len
1941
1942 .Lxts_enc_steal:
1943         movzb   ($inp),%eax                     # borrow $rounds ...
1944         movzb   -16($out),%ecx                  # ... and $key
1945         lea     1($inp),$inp
1946         mov     %al,-16($out)
1947         mov     %cl,0($out)
1948         lea     1($out),$out
1949         sub     \$1,$len
1950         jnz     .Lxts_enc_steal
1951
1952         sub     $len_,$out                      # rewind $out
1953         mov     $key_,$key                      # restore $key
1954         mov     $rnds_,$rounds                  # restore $rounds
1955
1956         movups  -16($out),$inout0
1957         xorps   @tweak[0],$inout0
1958 ___
1959         &aesni_generate1("enc",$key,$rounds);
1960 $code.=<<___;
1961         xorps   @tweak[0],$inout0
1962         movups  $inout0,-16($out)
1963
1964 .Lxts_enc_ret:
1965 ___
1966 $code.=<<___ if ($win64);
1967         movaps  -0xa0(%rbp),%xmm6
1968         movaps  -0x90(%rbp),%xmm7
1969         movaps  -0x80(%rbp),%xmm8
1970         movaps  -0x70(%rbp),%xmm9
1971         movaps  -0x60(%rbp),%xmm10
1972         movaps  -0x50(%rbp),%xmm11
1973         movaps  -0x40(%rbp),%xmm12
1974         movaps  -0x30(%rbp),%xmm13
1975         movaps  -0x20(%rbp),%xmm14
1976         movaps  -0x10(%rbp),%xmm15
1977 ___
1978 $code.=<<___;
1979         lea     (%rbp),%rsp
1980         pop     %rbp
1981 .Lxts_enc_epilogue:
1982         ret
1983 .size   aesni_xts_encrypt,.-aesni_xts_encrypt
1984 ___
1985
1986 $code.=<<___;
1987 .globl  aesni_xts_decrypt
1988 .type   aesni_xts_decrypt,\@function,6
1989 .align  16
1990 aesni_xts_decrypt:
1991         lea     (%rsp),%rax
1992         push    %rbp
1993         sub     \$$frame_size,%rsp
1994         and     \$-16,%rsp      # Linux kernel stack can be incorrectly seeded
1995 ___
1996 $code.=<<___ if ($win64);
1997         movaps  %xmm6,-0xa8(%rax)
1998         movaps  %xmm7,-0x98(%rax)
1999         movaps  %xmm8,-0x88(%rax)
2000         movaps  %xmm9,-0x78(%rax)
2001         movaps  %xmm10,-0x68(%rax)
2002         movaps  %xmm11,-0x58(%rax)
2003         movaps  %xmm12,-0x48(%rax)
2004         movaps  %xmm13,-0x38(%rax)
2005         movaps  %xmm14,-0x28(%rax)
2006         movaps  %xmm15,-0x18(%rax)
2007 .Lxts_dec_body:
2008 ___
2009 $code.=<<___;
2010         lea     -8(%rax),%rbp
2011         movups  ($ivp),$inout0                  # load clear-text tweak
2012         mov     240($key2),$rounds              # key2->rounds
2013         mov     240($key),$rnds_                # key1->rounds
2014 ___
2015         # generate the tweak
2016         &aesni_generate1("enc",$key2,$rounds,$inout0);
2017 $code.=<<___;
2018         xor     %eax,%eax                       # if ($len%16) len-=16;
2019         test    \$15,$len
2020         setnz   %al
2021         shl     \$4,%rax
2022         sub     %rax,$len
2023
2024         $movkey ($key),$rndkey0                 # zero round key
2025         mov     $key,$key_                      # backup $key
2026         mov     $rnds_,$rounds                  # backup $rounds
2027         shl     \$4,$rnds_
2028         mov     $len,$len_                      # backup $len
2029         and     \$-16,$len
2030
2031         $movkey 16($key,$rnds_),$rndkey1        # last round key
2032
2033         movdqa  .Lxts_magic(%rip),$twmask
2034         movdqa  $inout0,@tweak[5]
2035         pshufd  \$0x5f,$inout0,$twres
2036         pxor    $rndkey0,$rndkey1
2037 ___
2038     for ($i=0;$i<4;$i++) {
2039     $code.=<<___;
2040         movdqa  $twres,$twtmp
2041         paddd   $twres,$twres
2042         movdqa  @tweak[5],@tweak[$i]
2043         psrad   \$31,$twtmp                     # broadcast upper bits
2044         paddq   @tweak[5],@tweak[5]
2045         pand    $twmask,$twtmp
2046         pxor    $rndkey0,@tweak[$i]
2047         pxor    $twtmp,@tweak[5]
2048 ___
2049     }
2050 $code.=<<___;
2051         movdqa  @tweak[5],@tweak[4]
2052         psrad   \$31,$twres
2053         paddq   @tweak[5],@tweak[5]
2054         pand    $twmask,$twres
2055         pxor    $rndkey0,@tweak[4]
2056         pxor    $twres,@tweak[5]
2057         movaps  $rndkey1,0x60(%rsp)             # save round[0]^round[last]
2058
2059         sub     \$16*6,$len
2060         jc      .Lxts_dec_short
2061
2062         mov     \$16+96,$rounds
2063         lea     32($key_,$rnds_),$key           # end of key schedule
2064         sub     %r10,%rax                       # twisted $rounds
2065         $movkey 16($key_),$rndkey1
2066         mov     %rax,%r10                       # backup twisted $rounds
2067         lea     .Lxts_magic(%rip),%r8
2068         jmp     .Lxts_dec_grandloop
2069
2070 .align  32
2071 .Lxts_dec_grandloop:
2072         movdqu  `16*0`($inp),$inout0            # load input
2073         movdqa  $rndkey0,$twmask
2074         movdqu  `16*1`($inp),$inout1
2075         pxor    @tweak[0],$inout0
2076         movdqu  `16*2`($inp),$inout2
2077         pxor    @tweak[1],$inout1
2078          aesdec         $rndkey1,$inout0
2079         movdqu  `16*3`($inp),$inout3
2080         pxor    @tweak[2],$inout2
2081          aesdec         $rndkey1,$inout1
2082         movdqu  `16*4`($inp),$inout4
2083         pxor    @tweak[3],$inout3
2084          aesdec         $rndkey1,$inout2
2085         movdqu  `16*5`($inp),$inout5
2086         pxor    @tweak[5],$twmask               # round[0]^=tweak[5]
2087          movdqa 0x60(%rsp),$twres               # load round[0]^round[last]
2088         pxor    @tweak[4],$inout4
2089          aesdec         $rndkey1,$inout3
2090         $movkey 32($key_),$rndkey0
2091         lea     `16*6`($inp),$inp
2092         pxor    $twmask,$inout5
2093
2094          pxor   $twres,@tweak[0]
2095         aesdec          $rndkey1,$inout4
2096          pxor   $twres,@tweak[1]
2097          movdqa @tweak[0],`16*0`(%rsp)          # put aside tweaks^last round key
2098         aesdec          $rndkey1,$inout5
2099         $movkey         48($key_),$rndkey1
2100          pxor   $twres,@tweak[2]
2101
2102         aesdec          $rndkey0,$inout0
2103          pxor   $twres,@tweak[3]
2104          movdqa @tweak[1],`16*1`(%rsp)
2105         aesdec          $rndkey0,$inout1
2106          pxor   $twres,@tweak[4]
2107          movdqa @tweak[2],`16*2`(%rsp)
2108         aesdec          $rndkey0,$inout2
2109         aesdec          $rndkey0,$inout3
2110          pxor   $twres,$twmask
2111          movdqa @tweak[4],`16*4`(%rsp)
2112         aesdec          $rndkey0,$inout4
2113         aesdec          $rndkey0,$inout5
2114         $movkey         64($key_),$rndkey0
2115          movdqa $twmask,`16*5`(%rsp)
2116         pshufd  \$0x5f,@tweak[5],$twres
2117         jmp     .Lxts_dec_loop6
2118 .align  32
2119 .Lxts_dec_loop6:
2120         aesdec          $rndkey1,$inout0
2121         aesdec          $rndkey1,$inout1
2122         aesdec          $rndkey1,$inout2
2123         aesdec          $rndkey1,$inout3
2124         aesdec          $rndkey1,$inout4
2125         aesdec          $rndkey1,$inout5
2126         $movkey         -64($key,%rax),$rndkey1
2127         add             \$32,%rax
2128
2129         aesdec          $rndkey0,$inout0
2130         aesdec          $rndkey0,$inout1
2131         aesdec          $rndkey0,$inout2
2132         aesdec          $rndkey0,$inout3
2133         aesdec          $rndkey0,$inout4
2134         aesdec          $rndkey0,$inout5
2135         $movkey         -80($key,%rax),$rndkey0
2136         jnz             .Lxts_dec_loop6
2137
2138         movdqa  (%r8),$twmask
2139         movdqa  $twres,$twtmp
2140         paddd   $twres,$twres
2141          aesdec         $rndkey1,$inout0
2142         paddq   @tweak[5],@tweak[5]
2143         psrad   \$31,$twtmp
2144          aesdec         $rndkey1,$inout1
2145         pand    $twmask,$twtmp
2146         $movkey ($key_),@tweak[0]               # load round[0]
2147          aesdec         $rndkey1,$inout2
2148          aesdec         $rndkey1,$inout3
2149          aesdec         $rndkey1,$inout4
2150         pxor    $twtmp,@tweak[5]
2151         movaps  @tweak[0],@tweak[1]             # copy round[0]
2152          aesdec         $rndkey1,$inout5
2153          $movkey        -64($key),$rndkey1
2154
2155         movdqa  $twres,$twtmp
2156          aesdec         $rndkey0,$inout0
2157         paddd   $twres,$twres
2158         pxor    @tweak[5],@tweak[0]
2159          aesdec         $rndkey0,$inout1
2160         psrad   \$31,$twtmp
2161         paddq   @tweak[5],@tweak[5]
2162          aesdec         $rndkey0,$inout2
2163          aesdec         $rndkey0,$inout3
2164         pand    $twmask,$twtmp
2165         movaps  @tweak[1],@tweak[2]
2166          aesdec         $rndkey0,$inout4
2167         pxor    $twtmp,@tweak[5]
2168         movdqa  $twres,$twtmp
2169          aesdec         $rndkey0,$inout5
2170          $movkey        -48($key),$rndkey0
2171
2172         paddd   $twres,$twres
2173          aesdec         $rndkey1,$inout0
2174         pxor    @tweak[5],@tweak[1]
2175         psrad   \$31,$twtmp
2176          aesdec         $rndkey1,$inout1
2177         paddq   @tweak[5],@tweak[5]
2178         pand    $twmask,$twtmp
2179          aesdec         $rndkey1,$inout2
2180          aesdec         $rndkey1,$inout3
2181          movdqa @tweak[3],`16*3`(%rsp)
2182         pxor    $twtmp,@tweak[5]
2183          aesdec         $rndkey1,$inout4
2184         movaps  @tweak[2],@tweak[3]
2185         movdqa  $twres,$twtmp
2186          aesdec         $rndkey1,$inout5
2187          $movkey        -32($key),$rndkey1
2188
2189         paddd   $twres,$twres
2190          aesdec         $rndkey0,$inout0
2191         pxor    @tweak[5],@tweak[2]
2192         psrad   \$31,$twtmp
2193          aesdec         $rndkey0,$inout1
2194         paddq   @tweak[5],@tweak[5]
2195         pand    $twmask,$twtmp
2196          aesdec         $rndkey0,$inout2
2197          aesdec         $rndkey0,$inout3
2198          aesdec         $rndkey0,$inout4
2199         pxor    $twtmp,@tweak[5]
2200         movaps  @tweak[3],@tweak[4]
2201          aesdec         $rndkey0,$inout5
2202
2203         movdqa  $twres,$rndkey0
2204         paddd   $twres,$twres
2205          aesdec         $rndkey1,$inout0
2206         pxor    @tweak[5],@tweak[3]
2207         psrad   \$31,$rndkey0
2208          aesdec         $rndkey1,$inout1
2209         paddq   @tweak[5],@tweak[5]
2210         pand    $twmask,$rndkey0
2211          aesdec         $rndkey1,$inout2
2212          aesdec         $rndkey1,$inout3
2213         pxor    $rndkey0,@tweak[5]
2214         $movkey         ($key_),$rndkey0
2215          aesdec         $rndkey1,$inout4
2216          aesdec         $rndkey1,$inout5
2217         $movkey         16($key_),$rndkey1
2218
2219         pxor    @tweak[5],@tweak[4]
2220          aesdeclast     `16*0`(%rsp),$inout0
2221         psrad   \$31,$twres
2222         paddq   @tweak[5],@tweak[5]
2223          aesdeclast     `16*1`(%rsp),$inout1
2224          aesdeclast     `16*2`(%rsp),$inout2
2225         pand    $twmask,$twres
2226         mov     %r10,%rax                       # restore $rounds
2227          aesdeclast     `16*3`(%rsp),$inout3
2228          aesdeclast     `16*4`(%rsp),$inout4
2229          aesdeclast     `16*5`(%rsp),$inout5
2230         pxor    $twres,@tweak[5]
2231
2232         lea     `16*6`($out),$out
2233         movups  $inout0,`-16*6`($out)           # write output
2234         movups  $inout1,`-16*5`($out)
2235         movups  $inout2,`-16*4`($out)
2236         movups  $inout3,`-16*3`($out)
2237         movups  $inout4,`-16*2`($out)
2238         movups  $inout5,`-16*1`($out)
2239         sub     \$16*6,$len
2240         jnc     .Lxts_dec_grandloop
2241
2242         mov     \$16+96,$rounds
2243         sub     $rnds_,$rounds
2244         mov     $key_,$key                      # restore $key
2245         shr     \$4,$rounds                     # restore original value
2246
2247 .Lxts_dec_short:
2248         mov     $rounds,$rnds_                  # backup $rounds
2249         pxor    $rndkey0,@tweak[0]
2250         pxor    $rndkey0,@tweak[1]
2251         add     \$16*6,$len
2252         jz      .Lxts_dec_done
2253
2254         pxor    $rndkey0,@tweak[2]
2255         cmp     \$0x20,$len
2256         jb      .Lxts_dec_one
2257         pxor    $rndkey0,@tweak[3]
2258         je      .Lxts_dec_two
2259
2260         pxor    $rndkey0,@tweak[4]
2261         cmp     \$0x40,$len
2262         jb      .Lxts_dec_three
2263         je      .Lxts_dec_four
2264
2265         movdqu  ($inp),$inout0
2266         movdqu  16*1($inp),$inout1
2267         movdqu  16*2($inp),$inout2
2268         pxor    @tweak[0],$inout0
2269         movdqu  16*3($inp),$inout3
2270         pxor    @tweak[1],$inout1
2271         movdqu  16*4($inp),$inout4
2272         lea     16*5($inp),$inp
2273         pxor    @tweak[2],$inout2
2274         pxor    @tweak[3],$inout3
2275         pxor    @tweak[4],$inout4
2276
2277         call    _aesni_decrypt6
2278
2279         xorps   @tweak[0],$inout0
2280         xorps   @tweak[1],$inout1
2281         xorps   @tweak[2],$inout2
2282         movdqu  $inout0,($out)
2283         xorps   @tweak[3],$inout3
2284         movdqu  $inout1,16*1($out)
2285         xorps   @tweak[4],$inout4
2286         movdqu  $inout2,16*2($out)
2287          pxor           $twtmp,$twtmp
2288         movdqu  $inout3,16*3($out)
2289          pcmpgtd        @tweak[5],$twtmp
2290         movdqu  $inout4,16*4($out)
2291         lea     16*5($out),$out
2292          pshufd         \$0x13,$twtmp,@tweak[1] # $twres
2293         and     \$15,$len_
2294         jz      .Lxts_dec_ret
2295
2296         movdqa  @tweak[5],@tweak[0]
2297         paddq   @tweak[5],@tweak[5]             # psllq 1,$tweak
2298         pand    $twmask,@tweak[1]               # isolate carry and residue
2299         pxor    @tweak[5],@tweak[1]
2300         jmp     .Lxts_dec_done2
2301
2302 .align  16
2303 .Lxts_dec_one:
2304         movups  ($inp),$inout0
2305         lea     16*1($inp),$inp
2306         xorps   @tweak[0],$inout0
2307 ___
2308         &aesni_generate1("dec",$key,$rounds);
2309 $code.=<<___;
2310         xorps   @tweak[0],$inout0
2311         movdqa  @tweak[1],@tweak[0]
2312         movups  $inout0,($out)
2313         movdqa  @tweak[2],@tweak[1]
2314         lea     16*1($out),$out
2315         jmp     .Lxts_dec_done
2316
2317 .align  16
2318 .Lxts_dec_two:
2319         movups  ($inp),$inout0
2320         movups  16($inp),$inout1
2321         lea     32($inp),$inp
2322         xorps   @tweak[0],$inout0
2323         xorps   @tweak[1],$inout1
2324
2325         call    _aesni_decrypt3
2326
2327         xorps   @tweak[0],$inout0
2328         movdqa  @tweak[2],@tweak[0]
2329         xorps   @tweak[1],$inout1
2330         movdqa  @tweak[3],@tweak[1]
2331         movups  $inout0,($out)
2332         movups  $inout1,16*1($out)
2333         lea     16*2($out),$out
2334         jmp     .Lxts_dec_done
2335
2336 .align  16
2337 .Lxts_dec_three:
2338         movups  ($inp),$inout0
2339         movups  16*1($inp),$inout1
2340         movups  16*2($inp),$inout2
2341         lea     16*3($inp),$inp
2342         xorps   @tweak[0],$inout0
2343         xorps   @tweak[1],$inout1
2344         xorps   @tweak[2],$inout2
2345
2346         call    _aesni_decrypt3
2347
2348         xorps   @tweak[0],$inout0
2349         movdqa  @tweak[3],@tweak[0]
2350         xorps   @tweak[1],$inout1
2351         movdqa  @tweak[4],@tweak[1]
2352         xorps   @tweak[2],$inout2
2353         movups  $inout0,($out)
2354         movups  $inout1,16*1($out)
2355         movups  $inout2,16*2($out)
2356         lea     16*3($out),$out
2357         jmp     .Lxts_dec_done
2358
2359 .align  16
2360 .Lxts_dec_four:
2361         movups  ($inp),$inout0
2362         movups  16*1($inp),$inout1
2363         movups  16*2($inp),$inout2
2364         xorps   @tweak[0],$inout0
2365         movups  16*3($inp),$inout3
2366         lea     16*4($inp),$inp
2367         xorps   @tweak[1],$inout1
2368         xorps   @tweak[2],$inout2
2369         xorps   @tweak[3],$inout3
2370
2371         call    _aesni_decrypt4
2372
2373         pxor    @tweak[0],$inout0
2374         movdqa  @tweak[4],@tweak[0]
2375         pxor    @tweak[1],$inout1
2376         movdqa  @tweak[5],@tweak[1]
2377         pxor    @tweak[2],$inout2
2378         movdqu  $inout0,($out)
2379         pxor    @tweak[3],$inout3
2380         movdqu  $inout1,16*1($out)
2381         movdqu  $inout2,16*2($out)
2382         movdqu  $inout3,16*3($out)
2383         lea     16*4($out),$out
2384         jmp     .Lxts_dec_done
2385
2386 .align  16
2387 .Lxts_dec_done:
2388         and     \$15,$len_
2389         jz      .Lxts_dec_ret
2390 .Lxts_dec_done2:
2391         mov     $len_,$len
2392         mov     $key_,$key                      # restore $key
2393         mov     $rnds_,$rounds                  # restore $rounds
2394
2395         movups  ($inp),$inout0
2396         xorps   @tweak[1],$inout0
2397 ___
2398         &aesni_generate1("dec",$key,$rounds);
2399 $code.=<<___;
2400         xorps   @tweak[1],$inout0
2401         movups  $inout0,($out)
2402
2403 .Lxts_dec_steal:
2404         movzb   16($inp),%eax                   # borrow $rounds ...
2405         movzb   ($out),%ecx                     # ... and $key
2406         lea     1($inp),$inp
2407         mov     %al,($out)
2408         mov     %cl,16($out)
2409         lea     1($out),$out
2410         sub     \$1,$len
2411         jnz     .Lxts_dec_steal
2412
2413         sub     $len_,$out                      # rewind $out
2414         mov     $key_,$key                      # restore $key
2415         mov     $rnds_,$rounds                  # restore $rounds
2416
2417         movups  ($out),$inout0
2418         xorps   @tweak[0],$inout0
2419 ___
2420         &aesni_generate1("dec",$key,$rounds);
2421 $code.=<<___;
2422         xorps   @tweak[0],$inout0
2423         movups  $inout0,($out)
2424
2425 .Lxts_dec_ret:
2426 ___
2427 $code.=<<___ if ($win64);
2428         movaps  -0xa0(%rbp),%xmm6
2429         movaps  -0x90(%rbp),%xmm7
2430         movaps  -0x80(%rbp),%xmm8
2431         movaps  -0x70(%rbp),%xmm9
2432         movaps  -0x60(%rbp),%xmm10
2433         movaps  -0x50(%rbp),%xmm11
2434         movaps  -0x40(%rbp),%xmm12
2435         movaps  -0x30(%rbp),%xmm13
2436         movaps  -0x20(%rbp),%xmm14
2437         movaps  -0x10(%rbp),%xmm15
2438 ___
2439 $code.=<<___;
2440         lea     (%rbp),%rsp
2441         pop     %rbp
2442 .Lxts_dec_epilogue:
2443         ret
2444 .size   aesni_xts_decrypt,.-aesni_xts_decrypt
2445 ___
2446 } }}
2447 \f
2448 ########################################################################
2449 # void $PREFIX_cbc_encrypt (const void *inp, void *out,
2450 #                           size_t length, const AES_KEY *key,
2451 #                           unsigned char *ivp,const int enc);
2452 {
2453 my $frame_size = 0x10 + ($win64?0xa0:0);        # used in decrypt
2454 my ($iv,$in0,$in1,$in2,$in3,$in4)=map("%xmm$_",(10..15));
2455 my $inp_=$key_;
2456
2457 $code.=<<___;
2458 .globl  ${PREFIX}_cbc_encrypt
2459 .type   ${PREFIX}_cbc_encrypt,\@function,6
2460 .align  16
2461 ${PREFIX}_cbc_encrypt:
2462         test    $len,$len               # check length
2463         jz      .Lcbc_ret
2464
2465         mov     240($key),$rnds_        # key->rounds
2466         mov     $key,$key_              # backup $key
2467         test    %r9d,%r9d               # 6th argument
2468         jz      .Lcbc_decrypt
2469 #--------------------------- CBC ENCRYPT ------------------------------#
2470         movups  ($ivp),$inout0          # load iv as initial state
2471         mov     $rnds_,$rounds
2472         cmp     \$16,$len
2473         jb      .Lcbc_enc_tail
2474         sub     \$16,$len
2475         jmp     .Lcbc_enc_loop
2476 .align  16
2477 .Lcbc_enc_loop:
2478         movups  ($inp),$inout1          # load input
2479         lea     16($inp),$inp
2480         #xorps  $inout1,$inout0
2481 ___
2482         &aesni_generate1("enc",$key,$rounds,$inout0,$inout1);
2483 $code.=<<___;
2484         mov     $rnds_,$rounds          # restore $rounds
2485         mov     $key_,$key              # restore $key
2486         movups  $inout0,0($out)         # store output
2487         lea     16($out),$out
2488         sub     \$16,$len
2489         jnc     .Lcbc_enc_loop
2490         add     \$16,$len
2491         jnz     .Lcbc_enc_tail
2492         movups  $inout0,($ivp)
2493         jmp     .Lcbc_ret
2494
2495 .Lcbc_enc_tail:
2496         mov     $len,%rcx       # zaps $key
2497         xchg    $inp,$out       # $inp is %rsi and $out is %rdi now
2498         .long   0x9066A4F3      # rep movsb
2499         mov     \$16,%ecx       # zero tail
2500         sub     $len,%rcx
2501         xor     %eax,%eax
2502         .long   0x9066AAF3      # rep stosb
2503         lea     -16(%rdi),%rdi  # rewind $out by 1 block
2504         mov     $rnds_,$rounds  # restore $rounds
2505         mov     %rdi,%rsi       # $inp and $out are the same
2506         mov     $key_,$key      # restore $key
2507         xor     $len,$len       # len=16
2508         jmp     .Lcbc_enc_loop  # one more spin
2509 \f#--------------------------- CBC DECRYPT ------------------------------#
2510 .align  16
2511 .Lcbc_decrypt:
2512         lea     (%rsp),%rax
2513         push    %rbp
2514         sub     \$$frame_size,%rsp
2515         and     \$-16,%rsp      # Linux kernel stack can be incorrectly seeded
2516 ___
2517 $code.=<<___ if ($win64);
2518         movaps  %xmm6,0x10(%rsp)
2519         movaps  %xmm7,0x20(%rsp)
2520         movaps  %xmm8,0x30(%rsp)
2521         movaps  %xmm9,0x40(%rsp)
2522         movaps  %xmm10,0x50(%rsp)
2523         movaps  %xmm11,0x60(%rsp)
2524         movaps  %xmm12,0x70(%rsp)
2525         movaps  %xmm13,0x80(%rsp)
2526         movaps  %xmm14,0x90(%rsp)
2527         movaps  %xmm15,0xa0(%rsp)
2528 .Lcbc_decrypt_body:
2529 ___
2530 $code.=<<___;
2531         lea     -8(%rax),%rbp
2532         movups  ($ivp),$iv
2533         mov     $rnds_,$rounds
2534         cmp     \$0x50,$len
2535         jbe     .Lcbc_dec_tail
2536
2537         $movkey ($key),$rndkey0
2538         movdqu  0x00($inp),$inout0      # load input
2539         movdqu  0x10($inp),$inout1
2540         movdqa  $inout0,$in0
2541         movdqu  0x20($inp),$inout2
2542         movdqa  $inout1,$in1
2543         movdqu  0x30($inp),$inout3
2544         movdqa  $inout2,$in2
2545         movdqu  0x40($inp),$inout4
2546         movdqa  $inout3,$in3
2547         movdqu  0x50($inp),$inout5
2548         movdqa  $inout4,$in4
2549         mov     OPENSSL_ia32cap_P+4(%rip),%r9d
2550         cmp     \$0x70,$len
2551         jbe     .Lcbc_dec_six_or_seven
2552
2553         and     \$`1<<26|1<<22`,%r9d    # isolate XSAVE+MOVBE   
2554         sub     \$0x50,$len
2555         cmp     \$`1<<22`,%r9d          # check for MOVBE without XSAVE
2556         je      .Lcbc_dec_loop6_enter
2557         sub     \$0x20,$len
2558         lea     0x70($key),$key         # size optimization
2559         jmp     .Lcbc_dec_loop8_enter
2560 .align  16
2561 .Lcbc_dec_loop8:
2562         movups  $inout7,($out)
2563         lea     0x10($out),$out
2564 .Lcbc_dec_loop8_enter:
2565         movdqu          0x60($inp),$inout6
2566         pxor            $rndkey0,$inout0
2567         movdqu          0x70($inp),$inout7
2568         pxor            $rndkey0,$inout1
2569         $movkey         0x10-0x70($key),$rndkey1
2570         pxor            $rndkey0,$inout2
2571         xor             $inp_,$inp_
2572         cmp             \$0x70,$len     # is there at least 0x60 bytes ahead?
2573         pxor            $rndkey0,$inout3
2574         pxor            $rndkey0,$inout4
2575         pxor            $rndkey0,$inout5
2576         pxor            $rndkey0,$inout6
2577
2578         aesdec          $rndkey1,$inout0
2579         pxor            $rndkey0,$inout7
2580         $movkey         0x20-0x70($key),$rndkey0
2581         aesdec          $rndkey1,$inout1
2582         aesdec          $rndkey1,$inout2
2583         aesdec          $rndkey1,$inout3
2584         aesdec          $rndkey1,$inout4
2585         aesdec          $rndkey1,$inout5
2586         aesdec          $rndkey1,$inout6
2587         setnc           ${inp_}b
2588         shl             \$7,$inp_
2589         aesdec          $rndkey1,$inout7
2590         add             $inp,$inp_
2591         $movkey         0x30-0x70($key),$rndkey1
2592 ___
2593 for($i=1;$i<12;$i++) {
2594 my $rndkeyx = ($i&1)?$rndkey0:$rndkey1;
2595 $code.=<<___    if ($i==7);
2596         cmp             \$11,$rounds
2597 ___
2598 $code.=<<___;
2599         aesdec          $rndkeyx,$inout0
2600         aesdec          $rndkeyx,$inout1
2601         aesdec          $rndkeyx,$inout2
2602         aesdec          $rndkeyx,$inout3
2603         aesdec          $rndkeyx,$inout4
2604         aesdec          $rndkeyx,$inout5
2605         aesdec          $rndkeyx,$inout6
2606         aesdec          $rndkeyx,$inout7
2607         $movkey         `0x30+0x10*$i`-0x70($key),$rndkeyx
2608 ___
2609 $code.=<<___    if ($i<6 || (!($i&1) && $i>7));
2610         nop
2611 ___
2612 $code.=<<___    if ($i==7);
2613         jb              .Lcbc_dec_done
2614 ___
2615 $code.=<<___    if ($i==9);
2616         je              .Lcbc_dec_done
2617 ___
2618 $code.=<<___    if ($i==11);
2619         jmp             .Lcbc_dec_done
2620 ___
2621 }
2622 $code.=<<___;
2623 .align  16
2624 .Lcbc_dec_done:
2625         aesdec          $rndkey1,$inout0
2626         aesdec          $rndkey1,$inout1
2627         pxor            $rndkey0,$iv
2628         pxor            $rndkey0,$in0
2629         aesdec          $rndkey1,$inout2
2630         aesdec          $rndkey1,$inout3
2631         pxor            $rndkey0,$in1
2632         pxor            $rndkey0,$in2
2633         aesdec          $rndkey1,$inout4
2634         aesdec          $rndkey1,$inout5
2635         pxor            $rndkey0,$in3
2636         pxor            $rndkey0,$in4
2637         aesdec          $rndkey1,$inout6
2638         aesdec          $rndkey1,$inout7
2639         movdqu          0x50($inp),$rndkey1
2640
2641         aesdeclast      $iv,$inout0
2642         movdqu          0x60($inp),$iv          # borrow $iv
2643         pxor            $rndkey0,$rndkey1
2644         aesdeclast      $in0,$inout1
2645         pxor            $rndkey0,$iv
2646         movdqu          0x70($inp),$rndkey0     # next IV
2647         aesdeclast      $in1,$inout2
2648         lea             0x80($inp),$inp
2649         movdqu          0x00($inp_),$in0
2650         aesdeclast      $in2,$inout3
2651         aesdeclast      $in3,$inout4
2652         movdqu          0x10($inp_),$in1
2653         movdqu          0x20($inp_),$in2
2654         aesdeclast      $in4,$inout5
2655         aesdeclast      $rndkey1,$inout6
2656         movdqu          0x30($inp_),$in3
2657         movdqu          0x40($inp_),$in4
2658         aesdeclast      $iv,$inout7
2659         movdqa          $rndkey0,$iv            # return $iv
2660         movdqu          0x50($inp_),$rndkey1
2661         $movkey         -0x70($key),$rndkey0
2662
2663         movups          $inout0,($out)          # store output
2664         movdqa          $in0,$inout0
2665         movups          $inout1,0x10($out)
2666         movdqa          $in1,$inout1
2667         movups          $inout2,0x20($out)
2668         movdqa          $in2,$inout2
2669         movups          $inout3,0x30($out)
2670         movdqa          $in3,$inout3
2671         movups          $inout4,0x40($out)
2672         movdqa          $in4,$inout4
2673         movups          $inout5,0x50($out)
2674         movdqa          $rndkey1,$inout5
2675         movups          $inout6,0x60($out)
2676         lea             0x70($out),$out
2677
2678         sub     \$0x80,$len
2679         ja      .Lcbc_dec_loop8
2680
2681         movaps  $inout7,$inout0
2682         lea     -0x70($key),$key
2683         add     \$0x70,$len
2684         jle     .Lcbc_dec_tail_collected
2685         movups  $inout7,($out)
2686         lea     0x10($out),$out
2687         cmp     \$0x50,$len
2688         jbe     .Lcbc_dec_tail
2689
2690         movaps  $in0,$inout0
2691 .Lcbc_dec_six_or_seven:
2692         cmp     \$0x60,$len
2693         ja      .Lcbc_dec_seven
2694
2695         movaps  $inout5,$inout6
2696         call    _aesni_decrypt6
2697         pxor    $iv,$inout0             # ^= IV
2698         movaps  $inout6,$iv
2699         pxor    $in0,$inout1
2700         movdqu  $inout0,($out)
2701         pxor    $in1,$inout2
2702         movdqu  $inout1,0x10($out)
2703         pxor    $in2,$inout3
2704         movdqu  $inout2,0x20($out)
2705         pxor    $in3,$inout4
2706         movdqu  $inout3,0x30($out)
2707         pxor    $in4,$inout5
2708         movdqu  $inout4,0x40($out)
2709         lea     0x50($out),$out
2710         movdqa  $inout5,$inout0
2711         jmp     .Lcbc_dec_tail_collected
2712
2713 .align  16
2714 .Lcbc_dec_seven:
2715         movups  0x60($inp),$inout6
2716         xorps   $inout7,$inout7
2717         call    _aesni_decrypt8
2718         movups  0x50($inp),$inout7
2719         pxor    $iv,$inout0             # ^= IV
2720         movups  0x60($inp),$iv
2721         pxor    $in0,$inout1
2722         movdqu  $inout0,($out)
2723         pxor    $in1,$inout2
2724         movdqu  $inout1,0x10($out)
2725         pxor    $in2,$inout3
2726         movdqu  $inout2,0x20($out)
2727         pxor    $in3,$inout4
2728         movdqu  $inout3,0x30($out)
2729         pxor    $in4,$inout5
2730         movdqu  $inout4,0x40($out)
2731         pxor    $inout7,$inout6
2732         movdqu  $inout5,0x50($out)
2733         lea     0x60($out),$out
2734         movdqa  $inout6,$inout0
2735         jmp     .Lcbc_dec_tail_collected
2736
2737 .align  16
2738 .Lcbc_dec_loop6:
2739         movups  $inout5,($out)
2740         lea     0x10($out),$out
2741         movdqu  0x00($inp),$inout0      # load input
2742         movdqu  0x10($inp),$inout1
2743         movdqa  $inout0,$in0
2744         movdqu  0x20($inp),$inout2
2745         movdqa  $inout1,$in1
2746         movdqu  0x30($inp),$inout3
2747         movdqa  $inout2,$in2
2748         movdqu  0x40($inp),$inout4
2749         movdqa  $inout3,$in3
2750         movdqu  0x50($inp),$inout5
2751         movdqa  $inout4,$in4
2752 .Lcbc_dec_loop6_enter:
2753         lea     0x60($inp),$inp
2754         movdqa  $inout5,$inout6
2755
2756         call    _aesni_decrypt6
2757
2758         pxor    $iv,$inout0             # ^= IV
2759         movdqa  $inout6,$iv
2760         pxor    $in0,$inout1
2761         movdqu  $inout0,($out)
2762         pxor    $in1,$inout2
2763         movdqu  $inout1,0x10($out)
2764         pxor    $in2,$inout3
2765         movdqu  $inout2,0x20($out)
2766         pxor    $in3,$inout4
2767         mov     $key_,$key
2768         movdqu  $inout3,0x30($out)
2769         pxor    $in4,$inout5
2770         mov     $rnds_,$rounds
2771         movdqu  $inout4,0x40($out)
2772         lea     0x50($out),$out
2773         sub     \$0x60,$len
2774         ja      .Lcbc_dec_loop6
2775
2776         movdqa  $inout5,$inout0
2777         add     \$0x50,$len
2778         jle     .Lcbc_dec_tail_collected
2779         movups  $inout5,($out)
2780         lea     0x10($out),$out
2781
2782 .Lcbc_dec_tail:
2783         movups  ($inp),$inout0
2784         sub     \$0x10,$len
2785         jbe     .Lcbc_dec_one
2786
2787         movups  0x10($inp),$inout1
2788         movaps  $inout0,$in0
2789         sub     \$0x10,$len
2790         jbe     .Lcbc_dec_two
2791
2792         movups  0x20($inp),$inout2
2793         movaps  $inout1,$in1
2794         sub     \$0x10,$len
2795         jbe     .Lcbc_dec_three
2796
2797         movups  0x30($inp),$inout3
2798         movaps  $inout2,$in2
2799         sub     \$0x10,$len
2800         jbe     .Lcbc_dec_four
2801
2802         movups  0x40($inp),$inout4
2803         movaps  $inout3,$in3
2804         movaps  $inout4,$in4
2805         xorps   $inout5,$inout5
2806         call    _aesni_decrypt6
2807         pxor    $iv,$inout0
2808         movaps  $in4,$iv
2809         pxor    $in0,$inout1
2810         movdqu  $inout0,($out)
2811         pxor    $in1,$inout2
2812         movdqu  $inout1,0x10($out)
2813         pxor    $in2,$inout3
2814         movdqu  $inout2,0x20($out)
2815         pxor    $in3,$inout4
2816         movdqu  $inout3,0x30($out)
2817         lea     0x40($out),$out
2818         movdqa  $inout4,$inout0
2819         sub     \$0x10,$len
2820         jmp     .Lcbc_dec_tail_collected
2821
2822 .align  16
2823 .Lcbc_dec_one:
2824         movaps  $inout0,$in0
2825 ___
2826         &aesni_generate1("dec",$key,$rounds);
2827 $code.=<<___;
2828         xorps   $iv,$inout0
2829         movaps  $in0,$iv
2830         jmp     .Lcbc_dec_tail_collected
2831 .align  16
2832 .Lcbc_dec_two:
2833         movaps  $inout1,$in1
2834         xorps   $inout2,$inout2
2835         call    _aesni_decrypt3
2836         pxor    $iv,$inout0
2837         movaps  $in1,$iv
2838         pxor    $in0,$inout1
2839         movdqu  $inout0,($out)
2840         movdqa  $inout1,$inout0
2841         lea     0x10($out),$out
2842         jmp     .Lcbc_dec_tail_collected
2843 .align  16
2844 .Lcbc_dec_three:
2845         movaps  $inout2,$in2
2846         call    _aesni_decrypt3
2847         pxor    $iv,$inout0
2848         movaps  $in2,$iv
2849         pxor    $in0,$inout1
2850         movdqu  $inout0,($out)
2851         pxor    $in1,$inout2
2852         movdqu  $inout1,0x10($out)
2853         movdqa  $inout2,$inout0
2854         lea     0x20($out),$out
2855         jmp     .Lcbc_dec_tail_collected
2856 .align  16
2857 .Lcbc_dec_four:
2858         movaps  $inout3,$in3
2859         call    _aesni_decrypt4
2860         pxor    $iv,$inout0
2861         movaps  $in3,$iv
2862         pxor    $in0,$inout1
2863         movdqu  $inout0,($out)
2864         pxor    $in1,$inout2
2865         movdqu  $inout1,0x10($out)
2866         pxor    $in2,$inout3
2867         movdqu  $inout2,0x20($out)
2868         movdqa  $inout3,$inout0
2869         lea     0x30($out),$out
2870         jmp     .Lcbc_dec_tail_collected
2871
2872 .align  16
2873 .Lcbc_dec_tail_collected:
2874         movups  $iv,($ivp)
2875         and     \$15,$len
2876         jnz     .Lcbc_dec_tail_partial
2877         movups  $inout0,($out)
2878         jmp     .Lcbc_dec_ret
2879 .align  16
2880 .Lcbc_dec_tail_partial:
2881         movaps  $inout0,(%rsp)
2882         mov     \$16,%rcx
2883         mov     $out,%rdi
2884         sub     $len,%rcx
2885         lea     (%rsp),%rsi
2886         .long   0x9066A4F3      # rep movsb
2887
2888 .Lcbc_dec_ret:
2889 ___
2890 $code.=<<___ if ($win64);
2891         movaps  0x10(%rsp),%xmm6
2892         movaps  0x20(%rsp),%xmm7
2893         movaps  0x30(%rsp),%xmm8
2894         movaps  0x40(%rsp),%xmm9
2895         movaps  0x50(%rsp),%xmm10
2896         movaps  0x60(%rsp),%xmm11
2897         movaps  0x70(%rsp),%xmm12
2898         movaps  0x80(%rsp),%xmm13
2899         movaps  0x90(%rsp),%xmm14
2900         movaps  0xa0(%rsp),%xmm15
2901 ___
2902 $code.=<<___;
2903         lea     (%rbp),%rsp
2904         pop     %rbp
2905 .Lcbc_ret:
2906         ret
2907 .size   ${PREFIX}_cbc_encrypt,.-${PREFIX}_cbc_encrypt
2908 ___
2909\f
2910 # int $PREFIX_set_[en|de]crypt_key (const unsigned char *userKey,
2911 #                               int bits, AES_KEY *key)
2912 { my ($inp,$bits,$key) = @_4args;
2913   $bits =~ s/%r/%e/;
2914
2915 $code.=<<___;
2916 .globl  ${PREFIX}_set_decrypt_key
2917 .type   ${PREFIX}_set_decrypt_key,\@abi-omnipotent
2918 .align  16
2919 ${PREFIX}_set_decrypt_key:
2920         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
2921         call    __aesni_set_encrypt_key
2922         shl     \$4,$bits               # rounds-1 after _aesni_set_encrypt_key
2923         test    %eax,%eax
2924         jnz     .Ldec_key_ret
2925         lea     16($key,$bits),$inp     # points at the end of key schedule
2926
2927         $movkey ($key),%xmm0            # just swap
2928         $movkey ($inp),%xmm1
2929         $movkey %xmm0,($inp)
2930         $movkey %xmm1,($key)
2931         lea     16($key),$key
2932         lea     -16($inp),$inp
2933
2934 .Ldec_key_inverse:
2935         $movkey ($key),%xmm0            # swap and inverse
2936         $movkey ($inp),%xmm1
2937         aesimc  %xmm0,%xmm0
2938         aesimc  %xmm1,%xmm1
2939         lea     16($key),$key
2940         lea     -16($inp),$inp
2941         $movkey %xmm0,16($inp)
2942         $movkey %xmm1,-16($key)
2943         cmp     $key,$inp
2944         ja      .Ldec_key_inverse
2945
2946         $movkey ($key),%xmm0            # inverse middle
2947         aesimc  %xmm0,%xmm0
2948         $movkey %xmm0,($inp)
2949 .Ldec_key_ret:
2950         add     \$8,%rsp
2951         ret
2952 .LSEH_end_set_decrypt_key:
2953 .size   ${PREFIX}_set_decrypt_key,.-${PREFIX}_set_decrypt_key
2954 ___
2955 \f
2956 # This is based on submission by
2957 #
2958 #       Huang Ying <ying.huang@intel.com>
2959 #       Vinodh Gopal <vinodh.gopal@intel.com>
2960 #       Kahraman Akdemir
2961 #
2962 # Agressively optimized in respect to aeskeygenassist's critical path
2963 # and is contained in %xmm0-5 to meet Win64 ABI requirement.
2964 #
2965 $code.=<<___;
2966 .globl  ${PREFIX}_set_encrypt_key
2967 .type   ${PREFIX}_set_encrypt_key,\@abi-omnipotent
2968 .align  16
2969 ${PREFIX}_set_encrypt_key:
2970 __aesni_set_encrypt_key:
2971         .byte   0x48,0x83,0xEC,0x08     # sub rsp,8
2972         mov     \$-1,%rax
2973         test    $inp,$inp
2974         jz      .Lenc_key_ret
2975         test    $key,$key
2976         jz      .Lenc_key_ret
2977
2978         movups  ($inp),%xmm0            # pull first 128 bits of *userKey
2979         xorps   %xmm4,%xmm4             # low dword of xmm4 is assumed 0
2980         lea     16($key),%rax
2981         cmp     \$256,$bits
2982         je      .L14rounds
2983         cmp     \$192,$bits
2984         je      .L12rounds
2985         cmp     \$128,$bits
2986         jne     .Lbad_keybits
2987
2988 .L10rounds:
2989         mov     \$9,$bits                       # 10 rounds for 128-bit key
2990         $movkey %xmm0,($key)                    # round 0
2991         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 1
2992         call            .Lkey_expansion_128_cold
2993         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 2
2994         call            .Lkey_expansion_128
2995         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 3
2996         call            .Lkey_expansion_128
2997         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 4
2998         call            .Lkey_expansion_128
2999         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 5
3000         call            .Lkey_expansion_128
3001         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 6
3002         call            .Lkey_expansion_128
3003         aeskeygenassist \$0x40,%xmm0,%xmm1      # round 7
3004         call            .Lkey_expansion_128
3005         aeskeygenassist \$0x80,%xmm0,%xmm1      # round 8
3006         call            .Lkey_expansion_128
3007         aeskeygenassist \$0x1b,%xmm0,%xmm1      # round 9
3008         call            .Lkey_expansion_128
3009         aeskeygenassist \$0x36,%xmm0,%xmm1      # round 10
3010         call            .Lkey_expansion_128
3011         $movkey %xmm0,(%rax)
3012         mov     $bits,80(%rax)  # 240(%rdx)
3013         xor     %eax,%eax
3014         jmp     .Lenc_key_ret
3015
3016 .align  16
3017 .L12rounds:
3018         movq    16($inp),%xmm2                  # remaining 1/3 of *userKey
3019         mov     \$11,$bits                      # 12 rounds for 192
3020         $movkey %xmm0,($key)                    # round 0
3021         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 1,2
3022         call            .Lkey_expansion_192a_cold
3023         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 2,3
3024         call            .Lkey_expansion_192b
3025         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 4,5
3026         call            .Lkey_expansion_192a
3027         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 5,6
3028         call            .Lkey_expansion_192b
3029         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 7,8
3030         call            .Lkey_expansion_192a
3031         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 8,9
3032         call            .Lkey_expansion_192b
3033         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 10,11
3034         call            .Lkey_expansion_192a
3035         aeskeygenassist \$0x80,%xmm2,%xmm1      # round 11,12
3036         call            .Lkey_expansion_192b
3037         $movkey %xmm0,(%rax)
3038         mov     $bits,48(%rax)  # 240(%rdx)
3039         xor     %rax, %rax
3040         jmp     .Lenc_key_ret
3041
3042 .align  16
3043 .L14rounds:
3044         movups  16($inp),%xmm2                  # remaning half of *userKey
3045         mov     \$13,$bits                      # 14 rounds for 256
3046         lea     16(%rax),%rax
3047         $movkey %xmm0,($key)                    # round 0
3048         $movkey %xmm2,16($key)                  # round 1
3049         aeskeygenassist \$0x1,%xmm2,%xmm1       # round 2
3050         call            .Lkey_expansion_256a_cold
3051         aeskeygenassist \$0x1,%xmm0,%xmm1       # round 3
3052         call            .Lkey_expansion_256b
3053         aeskeygenassist \$0x2,%xmm2,%xmm1       # round 4
3054         call            .Lkey_expansion_256a
3055         aeskeygenassist \$0x2,%xmm0,%xmm1       # round 5
3056         call            .Lkey_expansion_256b
3057         aeskeygenassist \$0x4,%xmm2,%xmm1       # round 6
3058         call            .Lkey_expansion_256a
3059         aeskeygenassist \$0x4,%xmm0,%xmm1       # round 7
3060         call            .Lkey_expansion_256b
3061         aeskeygenassist \$0x8,%xmm2,%xmm1       # round 8
3062         call            .Lkey_expansion_256a
3063         aeskeygenassist \$0x8,%xmm0,%xmm1       # round 9
3064         call            .Lkey_expansion_256b
3065         aeskeygenassist \$0x10,%xmm2,%xmm1      # round 10
3066         call            .Lkey_expansion_256a
3067         aeskeygenassist \$0x10,%xmm0,%xmm1      # round 11
3068         call            .Lkey_expansion_256b
3069         aeskeygenassist \$0x20,%xmm2,%xmm1      # round 12
3070         call            .Lkey_expansion_256a
3071         aeskeygenassist \$0x20,%xmm0,%xmm1      # round 13
3072         call            .Lkey_expansion_256b
3073         aeskeygenassist \$0x40,%xmm2,%xmm1      # round 14
3074         call            .Lkey_expansion_256a
3075         $movkey %xmm0,(%rax)
3076         mov     $bits,16(%rax)  # 240(%rdx)
3077         xor     %rax,%rax
3078         jmp     .Lenc_key_ret
3079
3080 .align  16
3081 .Lbad_keybits:
3082         mov     \$-2,%rax
3083 .Lenc_key_ret:
3084         add     \$8,%rsp
3085         ret
3086 .LSEH_end_set_encrypt_key:
3087 \f
3088 .align  16
3089 .Lkey_expansion_128:
3090         $movkey %xmm0,(%rax)
3091         lea     16(%rax),%rax
3092 .Lkey_expansion_128_cold:
3093         shufps  \$0b00010000,%xmm0,%xmm4
3094         xorps   %xmm4, %xmm0
3095         shufps  \$0b10001100,%xmm0,%xmm4
3096         xorps   %xmm4, %xmm0
3097         shufps  \$0b11111111,%xmm1,%xmm1        # critical path
3098         xorps   %xmm1,%xmm0
3099         ret
3100
3101 .align 16
3102 .Lkey_expansion_192a:
3103         $movkey %xmm0,(%rax)
3104         lea     16(%rax),%rax
3105 .Lkey_expansion_192a_cold:
3106         movaps  %xmm2, %xmm5
3107 .Lkey_expansion_192b_warm:
3108         shufps  \$0b00010000,%xmm0,%xmm4
3109         movdqa  %xmm2,%xmm3
3110         xorps   %xmm4,%xmm0
3111         shufps  \$0b10001100,%xmm0,%xmm4
3112         pslldq  \$4,%xmm3
3113         xorps   %xmm4,%xmm0
3114         pshufd  \$0b01010101,%xmm1,%xmm1        # critical path
3115         pxor    %xmm3,%xmm2
3116         pxor    %xmm1,%xmm0
3117         pshufd  \$0b11111111,%xmm0,%xmm3
3118         pxor    %xmm3,%xmm2
3119         ret
3120
3121 .align 16
3122 .Lkey_expansion_192b:
3123         movaps  %xmm0,%xmm3
3124         shufps  \$0b01000100,%xmm0,%xmm5
3125         $movkey %xmm5,(%rax)
3126         shufps  \$0b01001110,%xmm2,%xmm3
3127         $movkey %xmm3,16(%rax)
3128         lea     32(%rax),%rax
3129         jmp     .Lkey_expansion_192b_warm
3130
3131 .align  16
3132 .Lkey_expansion_256a:
3133         $movkey %xmm2,(%rax)
3134         lea     16(%rax),%rax
3135 .Lkey_expansion_256a_cold:
3136         shufps  \$0b00010000,%xmm0,%xmm4
3137         xorps   %xmm4,%xmm0
3138         shufps  \$0b10001100,%xmm0,%xmm4
3139         xorps   %xmm4,%xmm0
3140         shufps  \$0b11111111,%xmm1,%xmm1        # critical path
3141         xorps   %xmm1,%xmm0
3142         ret
3143
3144 .align 16
3145 .Lkey_expansion_256b:
3146         $movkey %xmm0,(%rax)
3147         lea     16(%rax),%rax
3148
3149         shufps  \$0b00010000,%xmm2,%xmm4
3150         xorps   %xmm4,%xmm2
3151         shufps  \$0b10001100,%xmm2,%xmm4
3152         xorps   %xmm4,%xmm2
3153         shufps  \$0b10101010,%xmm1,%xmm1        # critical path
3154         xorps   %xmm1,%xmm2
3155         ret
3156 .size   ${PREFIX}_set_encrypt_key,.-${PREFIX}_set_encrypt_key
3157 .size   __aesni_set_encrypt_key,.-__aesni_set_encrypt_key
3158 ___
3159 }
3160 \f
3161 $code.=<<___;
3162 .align  64
3163 .Lbswap_mask:
3164         .byte   15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
3165 .Lincrement32:
3166         .long   6,6,6,0
3167 .Lincrement64:
3168         .long   1,0,0,0
3169 .Lxts_magic:
3170         .long   0x87,0,1,0
3171 .Lincrement1:
3172         .byte   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
3173
3174 .asciz  "AES for Intel AES-NI, CRYPTOGAMS by <appro\@openssl.org>"
3175 .align  64
3176 ___
3177
3178 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
3179 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
3180 if ($win64) {
3181 $rec="%rcx";
3182 $frame="%rdx";
3183 $context="%r8";
3184 $disp="%r9";
3185
3186 $code.=<<___;
3187 .extern __imp_RtlVirtualUnwind
3188 ___
3189 $code.=<<___ if ($PREFIX eq "aesni");
3190 .type   ecb_se_handler,\@abi-omnipotent
3191 .align  16
3192 ecb_se_handler:
3193         push    %rsi
3194         push    %rdi
3195         push    %rbx
3196         push    %rbp
3197         push    %r12
3198         push    %r13
3199         push    %r14
3200         push    %r15
3201         pushfq
3202         sub     \$64,%rsp
3203
3204         mov     152($context),%rax      # pull context->Rsp
3205
3206         jmp     .Lcommon_seh_tail
3207 .size   ecb_se_handler,.-ecb_se_handler
3208
3209 .type   ccm64_se_handler,\@abi-omnipotent
3210 .align  16
3211 ccm64_se_handler:
3212         push    %rsi
3213         push    %rdi
3214         push    %rbx
3215         push    %rbp
3216         push    %r12
3217         push    %r13
3218         push    %r14
3219         push    %r15
3220         pushfq
3221         sub     \$64,%rsp
3222
3223         mov     120($context),%rax      # pull context->Rax
3224         mov     248($context),%rbx      # pull context->Rip
3225
3226         mov     8($disp),%rsi           # disp->ImageBase
3227         mov     56($disp),%r11          # disp->HandlerData
3228
3229         mov     0(%r11),%r10d           # HandlerData[0]
3230         lea     (%rsi,%r10),%r10        # prologue label
3231         cmp     %r10,%rbx               # context->Rip<prologue label
3232         jb      .Lcommon_seh_tail
3233
3234         mov     152($context),%rax      # pull context->Rsp
3235
3236         mov     4(%r11),%r10d           # HandlerData[1]
3237         lea     (%rsi,%r10),%r10        # epilogue label
3238         cmp     %r10,%rbx               # context->Rip>=epilogue label
3239         jae     .Lcommon_seh_tail
3240
3241         lea     0(%rax),%rsi            # %xmm save area
3242         lea     512($context),%rdi      # &context.Xmm6
3243         mov     \$8,%ecx                # 4*sizeof(%xmm0)/sizeof(%rax)
3244         .long   0xa548f3fc              # cld; rep movsq
3245         lea     0x58(%rax),%rax         # adjust stack pointer
3246
3247         jmp     .Lcommon_seh_tail
3248 .size   ccm64_se_handler,.-ccm64_se_handler
3249
3250 .type   ctr_xts_se_handler,\@abi-omnipotent
3251 .align  16
3252 ctr_xts_se_handler:
3253         push    %rsi
3254         push    %rdi
3255         push    %rbx
3256         push    %rbp
3257         push    %r12
3258         push    %r13
3259         push    %r14
3260         push    %r15
3261         pushfq
3262         sub     \$64,%rsp
3263
3264         mov     120($context),%rax      # pull context->Rax
3265         mov     248($context),%rbx      # pull context->Rip
3266
3267         mov     8($disp),%rsi           # disp->ImageBase
3268         mov     56($disp),%r11          # disp->HandlerData
3269
3270         mov     0(%r11),%r10d           # HandlerData[0]
3271         lea     (%rsi,%r10),%r10        # prologue lable
3272         cmp     %r10,%rbx               # context->Rip<prologue label
3273         jb      .Lcommon_seh_tail
3274
3275         mov     152($context),%rax      # pull context->Rsp
3276
3277         mov     4(%r11),%r10d           # HandlerData[1]
3278         lea     (%rsi,%r10),%r10        # epilogue label
3279         cmp     %r10,%rbx               # context->Rip>=epilogue label
3280         jae     .Lcommon_seh_tail
3281
3282         mov     160($context),%rax      # pull context->Rbp
3283         lea     -0xa0(%rax),%rsi        # %xmm save area
3284         lea     512($context),%rdi      # & context.Xmm6
3285         mov     \$20,%ecx               # 10*sizeof(%xmm0)/sizeof(%rax)
3286         .long   0xa548f3fc              # cld; rep movsq
3287
3288         jmp     .Lcommon_rbp_tail
3289 .size   ctr_xts_se_handler,.-ctr_xts_se_handler
3290 ___
3291 $code.=<<___;
3292 .type   cbc_se_handler,\@abi-omnipotent
3293 .align  16
3294 cbc_se_handler:
3295         push    %rsi
3296         push    %rdi
3297         push    %rbx
3298         push    %rbp
3299         push    %r12
3300         push    %r13
3301         push    %r14
3302         push    %r15
3303         pushfq
3304         sub     \$64,%rsp
3305
3306         mov     152($context),%rax      # pull context->Rsp
3307         mov     248($context),%rbx      # pull context->Rip
3308
3309         lea     .Lcbc_decrypt(%rip),%r10
3310         cmp     %r10,%rbx               # context->Rip<"prologue" label
3311         jb      .Lcommon_seh_tail
3312
3313         lea     .Lcbc_decrypt_body(%rip),%r10
3314         cmp     %r10,%rbx               # context->Rip<cbc_decrypt_body
3315         jb      .Lrestore_cbc_rax
3316
3317         lea     .Lcbc_ret(%rip),%r10
3318         cmp     %r10,%rbx               # context->Rip>="epilogue" label
3319         jae     .Lcommon_seh_tail
3320
3321         lea     16(%rax),%rsi           # %xmm save area
3322         lea     512($context),%rdi      # &context.Xmm6
3323         mov     \$20,%ecx               # 10*sizeof(%xmm0)/sizeof(%rax)
3324         .long   0xa548f3fc              # cld; rep movsq
3325
3326 .Lcommon_rbp_tail:
3327         mov     160($context),%rax      # pull context->Rbp
3328         mov     (%rax),%rbp             # restore saved %rbp
3329         lea     8(%rax),%rax            # adjust stack pointer
3330         mov     %rbp,160($context)      # restore context->Rbp
3331         jmp     .Lcommon_seh_tail
3332
3333 .Lrestore_cbc_rax:
3334         mov     120($context),%rax
3335
3336 .Lcommon_seh_tail:
3337         mov     8(%rax),%rdi
3338         mov     16(%rax),%rsi
3339         mov     %rax,152($context)      # restore context->Rsp
3340         mov     %rsi,168($context)      # restore context->Rsi
3341         mov     %rdi,176($context)      # restore context->Rdi
3342
3343         mov     40($disp),%rdi          # disp->ContextRecord
3344         mov     $context,%rsi           # context
3345         mov     \$154,%ecx              # sizeof(CONTEXT)
3346         .long   0xa548f3fc              # cld; rep movsq
3347
3348         mov     $disp,%rsi
3349         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
3350         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
3351         mov     0(%rsi),%r8             # arg3, disp->ControlPc
3352         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
3353         mov     40(%rsi),%r10           # disp->ContextRecord
3354         lea     56(%rsi),%r11           # &disp->HandlerData
3355         lea     24(%rsi),%r12           # &disp->EstablisherFrame
3356         mov     %r10,32(%rsp)           # arg5
3357         mov     %r11,40(%rsp)           # arg6
3358         mov     %r12,48(%rsp)           # arg7
3359         mov     %rcx,56(%rsp)           # arg8, (NULL)
3360         call    *__imp_RtlVirtualUnwind(%rip)
3361
3362         mov     \$1,%eax                # ExceptionContinueSearch
3363         add     \$64,%rsp
3364         popfq
3365         pop     %r15
3366         pop     %r14
3367         pop     %r13
3368         pop     %r12
3369         pop     %rbp
3370         pop     %rbx
3371         pop     %rdi
3372         pop     %rsi
3373         ret
3374 .size   cbc_se_handler,.-cbc_se_handler
3375
3376 .section        .pdata
3377 .align  4
3378 ___
3379 $code.=<<___ if ($PREFIX eq "aesni");
3380         .rva    .LSEH_begin_aesni_ecb_encrypt
3381         .rva    .LSEH_end_aesni_ecb_encrypt
3382         .rva    .LSEH_info_ecb
3383
3384         .rva    .LSEH_begin_aesni_ccm64_encrypt_blocks
3385         .rva    .LSEH_end_aesni_ccm64_encrypt_blocks
3386         .rva    .LSEH_info_ccm64_enc
3387
3388         .rva    .LSEH_begin_aesni_ccm64_decrypt_blocks
3389         .rva    .LSEH_end_aesni_ccm64_decrypt_blocks
3390         .rva    .LSEH_info_ccm64_dec
3391
3392         .rva    .LSEH_begin_aesni_ctr32_encrypt_blocks
3393         .rva    .LSEH_end_aesni_ctr32_encrypt_blocks
3394         .rva    .LSEH_info_ctr32
3395
3396         .rva    .LSEH_begin_aesni_xts_encrypt
3397         .rva    .LSEH_end_aesni_xts_encrypt
3398         .rva    .LSEH_info_xts_enc
3399
3400         .rva    .LSEH_begin_aesni_xts_decrypt
3401         .rva    .LSEH_end_aesni_xts_decrypt
3402         .rva    .LSEH_info_xts_dec
3403 ___
3404 $code.=<<___;
3405         .rva    .LSEH_begin_${PREFIX}_cbc_encrypt
3406         .rva    .LSEH_end_${PREFIX}_cbc_encrypt
3407         .rva    .LSEH_info_cbc
3408
3409         .rva    ${PREFIX}_set_decrypt_key
3410         .rva    .LSEH_end_set_decrypt_key
3411         .rva    .LSEH_info_key
3412
3413         .rva    ${PREFIX}_set_encrypt_key
3414         .rva    .LSEH_end_set_encrypt_key
3415         .rva    .LSEH_info_key
3416 .section        .xdata
3417 .align  8
3418 ___
3419 $code.=<<___ if ($PREFIX eq "aesni");
3420 .LSEH_info_ecb:
3421         .byte   9,0,0,0
3422         .rva    ecb_se_handler
3423 .LSEH_info_ccm64_enc:
3424         .byte   9,0,0,0
3425         .rva    ccm64_se_handler
3426         .rva    .Lccm64_enc_body,.Lccm64_enc_ret        # HandlerData[]
3427 .LSEH_info_ccm64_dec:
3428         .byte   9,0,0,0
3429         .rva    ccm64_se_handler
3430         .rva    .Lccm64_dec_body,.Lccm64_dec_ret        # HandlerData[]
3431 .LSEH_info_ctr32:
3432         .byte   9,0,0,0
3433         .rva    ctr_xts_se_handler
3434         .rva    .Lctr32_body,.Lctr32_epilogue           # HandlerData[]
3435 .LSEH_info_xts_enc:
3436         .byte   9,0,0,0
3437         .rva    ctr_xts_se_handler
3438         .rva    .Lxts_enc_body,.Lxts_enc_epilogue       # HandlerData[]
3439 .LSEH_info_xts_dec:
3440         .byte   9,0,0,0
3441         .rva    ctr_xts_se_handler
3442         .rva    .Lxts_dec_body,.Lxts_dec_epilogue       # HandlerData[]
3443 ___
3444 $code.=<<___;
3445 .LSEH_info_cbc:
3446         .byte   9,0,0,0
3447         .rva    cbc_se_handler
3448 .LSEH_info_key:
3449         .byte   0x01,0x04,0x01,0x00
3450         .byte   0x04,0x02,0x00,0x00     # sub rsp,8
3451 ___
3452 }
3453
3454 sub rex {
3455   local *opcode=shift;
3456   my ($dst,$src)=@_;
3457   my $rex=0;
3458
3459     $rex|=0x04                  if($dst>=8);
3460     $rex|=0x01                  if($src>=8);
3461     push @opcode,$rex|0x40      if($rex);
3462 }
3463
3464 sub aesni {
3465   my $line=shift;
3466   my @opcode=(0x66);
3467
3468     if ($line=~/(aeskeygenassist)\s+\$([x0-9a-f]+),\s*%xmm([0-9]+),\s*%xmm([0-9]+)/) {
3469         rex(\@opcode,$4,$3);
3470         push @opcode,0x0f,0x3a,0xdf;
3471         push @opcode,0xc0|($3&7)|(($4&7)<<3);   # ModR/M
3472         my $c=$2;
3473         push @opcode,$c=~/^0/?oct($c):$c;
3474         return ".byte\t".join(',',@opcode);
3475     }
3476     elsif ($line=~/(aes[a-z]+)\s+%xmm([0-9]+),\s*%xmm([0-9]+)/) {
3477         my %opcodelet = (
3478                 "aesimc" => 0xdb,
3479                 "aesenc" => 0xdc,       "aesenclast" => 0xdd,
3480                 "aesdec" => 0xde,       "aesdeclast" => 0xdf
3481         );
3482         return undef if (!defined($opcodelet{$1}));
3483         rex(\@opcode,$3,$2);
3484         push @opcode,0x0f,0x38,$opcodelet{$1};
3485         push @opcode,0xc0|($2&7)|(($3&7)<<3);   # ModR/M
3486         return ".byte\t".join(',',@opcode);
3487     }
3488     elsif ($line=~/(aes[a-z]+)\s+([0x1-9a-fA-F]*)\(%rsp\),\s*%xmm([0-9]+)/) {
3489         my %opcodelet = (
3490                 "aesenc" => 0xdc,       "aesenclast" => 0xdd,
3491                 "aesdec" => 0xde,       "aesdeclast" => 0xdf
3492         );
3493         return undef if (!defined($opcodelet{$1}));
3494         my $off = $2;
3495         push @opcode,0x44 if ($3>=8);
3496         push @opcode,0x0f,0x38,$opcodelet{$1};
3497         push @opcode,0x44|(($3&7)<<3),0x24;     # ModR/M
3498         push @opcode,($off=~/^0/?oct($off):$off)&0xff;
3499         return ".byte\t".join(',',@opcode);
3500     }
3501     return $line;
3502 }
3503
3504 sub movbe {
3505         ".byte  0x0f,0x38,0xf1,0x44,0x24,".shift;
3506 }
3507
3508 $code =~ s/\`([^\`]*)\`/eval($1)/gem;
3509 $code =~ s/\b(aes.*%xmm[0-9]+).*$/aesni($1)/gem;
3510 #$code =~ s/\bmovbe\s+%eax/bswap %eax; mov %eax/gm;     # debugging artefact
3511 $code =~ s/\bmovbe\s+%eax,\s*([0-9]+)\(%rsp\)/movbe($1)/gem;
3512
3513 print $code;
3514
3515 close STDOUT;