aesni-x86[_64].pl: fine-tune, add CCM subroutine, add performance data.
[openssl.git] / crypto / aes / asm / aesni-x86.pl
1 #!/usr/bin/env perl
2
3 # ====================================================================
4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
5 # project. The module is, however, dual licensed under OpenSSL and
6 # CRYPTOGAMS licenses depending on where you obtain it. For further
7 # details see http://www.openssl.org/~appro/cryptogams/.
8 # ====================================================================
9 #
10 # This module implements support for Intel AES-NI extension. In
11 # OpenSSL context it's used with Intel engine, but can also be used as
12 # drop-in replacement for crypto/aes/asm/aes-586.pl [see below for
13 # details].
14 #
15 # Performance.
16 #
17 # To start with see corresponding paragraph in aesni-x86_64.pl...
18 # Instead of filling table similar to one found there I've chosen to
19 # summarize *comparison* results for raw ECB, CTR and CBC benchmarks.
20 # The simplified table below represents 32-bit performance relative
21 # to 64-bit one in every given point. Ratios vary for different
22 # encryption modes, therefore interval values.
23 #
24 #       16-byte     64-byte     256-byte    1-KB        8-KB
25 #       53-67%      67-84%      91-94%      95-98%      97-99.5%
26 #
27 # Lower ratios for smaller block sizes are perfectly understandable,
28 # because function call overhead is higher in 32-bit mode. Largest
29 # 8-KB block performance is virtually same: 32-bit code is less than
30 # 1% slower for ECB, CBC and CCM, and ~3% slower otherwise. 
31
32 $PREFIX="aesni";        # if $PREFIX is set to "AES", the script
33                         # generates drop-in replacement for
34                         # crypto/aes/asm/aes-586.pl:-)
35 $inline=1;              # inline _aesni_[en|de]crypt
36
37 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
38 push(@INC,"${dir}","${dir}../../perlasm");
39 require "x86asm.pl";
40
41 &asm_init($ARGV[0],$0);
42
43 if ($PREFIX eq "aesni") { $movekey=*movaps; }
44 else                    { $movekey=*movups; }
45
46 $len="eax";
47 $rounds="ecx";
48 $key="edx";
49 $inp="esi";
50 $out="edi";
51 $rounds_="ebx"; # backup copy for $rounds
52 $key_="ebp";    # backup copy for $key
53
54 $inout0="xmm0";
55 $inout1="xmm1";
56 $inout2="xmm2";
57 $rndkey0="xmm3";
58 $rndkey1="xmm4";
59 $ivec="xmm5";
60 $in0="xmm6";
61 $in1="xmm7";    $inout3="xmm7";
62 \f
63 # Inline version of internal aesni_[en|de]crypt1
64 { my $sn;
65 sub aesni_inline_generate1
66 { my ($p,$inout)=@_; $inout=$inout0 if (!defined($inout));
67   $sn++;
68
69     &$movekey           ($rndkey0,&QWP(0,$key));
70     &$movekey           ($rndkey1,&QWP(16,$key));
71     &lea                ($key,&DWP(32,$key));
72     &pxor               ($inout,$rndkey0);
73     &set_label("${p}1_loop_$sn");
74         eval"&aes${p}   ($inout,$rndkey1)";
75         &dec            ($rounds);
76         &$movekey       ($rndkey1,&QWP(0,$key));
77         &lea            ($key,&DWP(16,$key));
78     &jnz                (&label("${p}1_loop_$sn"));
79     eval"&aes${p}last   ($inout,$rndkey1)";
80 }}
81
82 sub aesni_generate1     # fully unrolled loop
83 { my ($p,$inout)=@_; $inout=$inout0 if (!defined($inout));
84
85     &function_begin_B("_aesni_${p}rypt1");
86         &$movekey       ($rndkey0,&QWP(0,$key));
87         &$movekey       ($rndkey1,&QWP(0x10,$key));
88         &pxor           ($inout,$rndkey0);
89         &$movekey       ($rndkey0,&QWP(0x20,$key));
90         &lea            ($key,&DWP(0x30,$key));
91         &cmp            ($rounds,11);
92         &jb             (&label("${p}128"));
93         &lea            ($key,&DWP(0x20,$key));
94         &je             (&label("${p}192"));
95         &lea            ($key,&DWP(0x20,$key));
96         eval"&aes${p}   ($inout,$rndkey1)";
97         &$movekey       ($rndkey1,&QWP(-0x40,$key));
98         eval"&aes${p}   ($inout,$rndkey0)";
99         &$movekey       ($rndkey0,&QWP(-0x30,$key));
100     &set_label("${p}192");
101         eval"&aes${p}   ($inout,$rndkey1)";
102         &$movekey       ($rndkey1,&QWP(-0x20,$key));
103         eval"&aes${p}   ($inout,$rndkey0)";
104         &$movekey       ($rndkey0,&QWP(-0x10,$key));
105     &set_label("${p}128");
106         eval"&aes${p}   ($inout,$rndkey1)";
107         &$movekey       ($rndkey1,&QWP(0,$key));
108         eval"&aes${p}   ($inout,$rndkey0)";
109         &$movekey       ($rndkey0,&QWP(0x10,$key));
110         eval"&aes${p}   ($inout,$rndkey1)";
111         &$movekey       ($rndkey1,&QWP(0x20,$key));
112         eval"&aes${p}   ($inout,$rndkey0)";
113         &$movekey       ($rndkey0,&QWP(0x30,$key));
114         eval"&aes${p}   ($inout,$rndkey1)";
115         &$movekey       ($rndkey1,&QWP(0x40,$key));
116         eval"&aes${p}   ($inout,$rndkey0)";
117         &$movekey       ($rndkey0,&QWP(0x50,$key));
118         eval"&aes${p}   ($inout,$rndkey1)";
119         &$movekey       ($rndkey1,&QWP(0x60,$key));
120         eval"&aes${p}   ($inout,$rndkey0)";
121         &$movekey       ($rndkey0,&QWP(0x70,$key));
122         eval"&aes${p}   ($inout,$rndkey1)";
123     eval"&aes${p}last   ($inout,$rndkey0)";
124     &ret();
125     &function_end_B("_aesni_${p}rypt1");
126 }
127 \f
128 # void $PREFIX_encrypt (const void *inp,void *out,const AES_KEY *key);
129 &aesni_generate1("enc") if (!$inline);
130 &function_begin_B("${PREFIX}_encrypt");
131         &mov    ("eax",&wparam(0));
132         &mov    ($key,&wparam(2));
133         &movups ($inout0,&QWP(0,"eax"));
134         &mov    ($rounds,&DWP(240,$key));
135         &mov    ("eax",&wparam(1));
136         if ($inline)
137         {   &aesni_inline_generate1("enc");     }
138         else
139         {   &call       ("_aesni_encrypt1");    }
140         &movups (&QWP(0,"eax"),$inout0);
141         &ret    ();
142 &function_end_B("${PREFIX}_encrypt");
143
144 # void $PREFIX_decrypt (const void *inp,void *out,const AES_KEY *key);
145 &aesni_generate1("dec") if(!$inline);
146 &function_begin_B("${PREFIX}_decrypt");
147         &mov    ("eax",&wparam(0));
148         &mov    ($key,&wparam(2));
149         &movups ($inout0,&QWP(0,"eax"));
150         &mov    ($rounds,&DWP(240,$key));
151         &mov    ("eax",&wparam(1));
152         if ($inline)
153         {   &aesni_inline_generate1("dec");     }
154         else
155         {   &call       ("_aesni_decrypt1");    }
156         &movups (&QWP(0,"eax"),$inout0);
157         &ret    ();
158 &function_end_B("${PREFIX}_decrypt");
159
160 # _aesni_[en|de]crypt[34] are private interfaces, N denotes interleave
161 # factor. Why 3x subroutine is used in loops? Even though aes[enc|dec]
162 # latency is 6, it turned out that it can be scheduled only every
163 # *second* cycle. Thus 3x interleave is the one providing optimal
164 # utilization, i.e. when subroutine's throughput is virtually same as
165 # of non-interleaved subroutine [for number of input blocks up to 3].
166 # This is why it makes no sense to implement 2x subroutine. As soon
167 # as/if Intel improves throughput by making it possible to schedule
168 # the instructions in question *every* cycles I would have to
169 # implement 6x interleave and use it in loop...
170 sub aesni_generate3
171 { my $p=shift;
172
173     &function_begin_B("_aesni_${p}rypt3");
174         &$movekey       ($rndkey0,&QWP(0,$key));
175         &shr            ($rounds,1);
176         &$movekey       ($rndkey1,&QWP(16,$key));
177         &lea            ($key,&DWP(32,$key));
178         &pxor           ($inout0,$rndkey0);
179         &pxor           ($inout1,$rndkey0);
180         &pxor           ($inout2,$rndkey0);
181         &$movekey       ($rndkey0,&QWP(0,$key));
182
183     &set_label("${p}3_loop");
184         eval"&aes${p}   ($inout0,$rndkey1)";
185         eval"&aes${p}   ($inout1,$rndkey1)";
186         &dec            ($rounds);
187         eval"&aes${p}   ($inout2,$rndkey1)";
188         &$movekey       ($rndkey1,&QWP(16,$key));
189         eval"&aes${p}   ($inout0,$rndkey0)";
190         eval"&aes${p}   ($inout1,$rndkey0)";
191         &lea            ($key,&DWP(32,$key));
192         eval"&aes${p}   ($inout2,$rndkey0)";
193         &$movekey       ($rndkey0,&QWP(0,$key));
194         &jnz            (&label("${p}3_loop"));
195     eval"&aes${p}       ($inout0,$rndkey1)";
196     eval"&aes${p}       ($inout1,$rndkey1)";
197     eval"&aes${p}       ($inout2,$rndkey1)";
198     eval"&aes${p}last   ($inout0,$rndkey0)";
199     eval"&aes${p}last   ($inout1,$rndkey0)";
200     eval"&aes${p}last   ($inout2,$rndkey0)";
201     &ret();
202     &function_end_B("_aesni_${p}rypt3");
203 }
204
205 # 4x interleave is implemented to improve small block performance,
206 # most notably [and naturally] 4 block by ~30%. One can argue that one
207 # should have implemented 5x as well, but improvement  would be <20%,
208 # so it's not worth it...
209 sub aesni_generate4
210 { my $p=shift;
211
212     &function_begin_B("_aesni_${p}rypt4");
213         &$movekey       ($rndkey0,&QWP(0,$key));
214         &$movekey       ($rndkey1,&QWP(16,$key));
215         &shr            ($rounds,1);
216         &lea            ($key,&DWP(32,$key));
217         &pxor           ($inout0,$rndkey0);
218         &pxor           ($inout1,$rndkey0);
219         &pxor           ($inout2,$rndkey0);
220         &pxor           ($inout3,$rndkey0);
221         &$movekey       ($rndkey0,&QWP(0,$key));
222
223     &set_label("${p}3_loop");
224         eval"&aes${p}   ($inout0,$rndkey1)";
225         eval"&aes${p}   ($inout1,$rndkey1)";
226         &dec            ($rounds);
227         eval"&aes${p}   ($inout2,$rndkey1)";
228         eval"&aes${p}   ($inout3,$rndkey1)";
229         &$movekey       ($rndkey1,&QWP(16,$key));
230         eval"&aes${p}   ($inout0,$rndkey0)";
231         eval"&aes${p}   ($inout1,$rndkey0)";
232         &lea            ($key,&DWP(32,$key));
233         eval"&aes${p}   ($inout2,$rndkey0)";
234         eval"&aes${p}   ($inout3,$rndkey0)";
235         &$movekey       ($rndkey0,&QWP(0,$key));
236     &jnz                (&label("${p}3_loop"));
237
238     eval"&aes${p}       ($inout0,$rndkey1)";
239     eval"&aes${p}       ($inout1,$rndkey1)";
240     eval"&aes${p}       ($inout2,$rndkey1)";
241     eval"&aes${p}       ($inout3,$rndkey1)";
242     eval"&aes${p}last   ($inout0,$rndkey0)";
243     eval"&aes${p}last   ($inout1,$rndkey0)";
244     eval"&aes${p}last   ($inout2,$rndkey0)";
245     eval"&aes${p}last   ($inout3,$rndkey0)";
246     &ret();
247     &function_end_B("_aesni_${p}rypt4");
248 }
249 &aesni_generate3("enc") if ($PREFIX eq "aesni");
250 &aesni_generate3("dec");
251 &aesni_generate4("enc") if ($PREFIX eq "aesni");
252 &aesni_generate4("dec");
253 \f
254 if ($PREFIX eq "aesni") {
255 ######################################################################
256 # void aesni_ecb_encrypt (const void *in, void *out,
257 #                         size_t length, const AES_KEY *key,
258 #                         int enc);
259 &function_begin("aesni_ecb_encrypt");
260         &mov    ($inp,&wparam(0));
261         &mov    ($out,&wparam(1));
262         &mov    ($len,&wparam(2));
263         &mov    ($key,&wparam(3));
264         &mov    ($rounds,&wparam(4));
265         &cmp    ($len,16);
266         &jb     (&label("ecb_ret"));
267         &and    ($len,-16);
268         &test   ($rounds,$rounds)
269         &mov    ($rounds,&DWP(240,$key));
270         &mov    ($key_,$key);           # backup $key
271         &mov    ($rounds_,$rounds);     # backup $rounds
272         &jz     (&label("ecb_decrypt"));
273
274         &cmp    ($len,0x40);
275         &jbe    (&label("ecb_enc_tail"));
276         &sub    ($len,0x40);
277         &jmp    (&label("ecb_enc_loop3"));
278
279 &set_label("ecb_enc_loop3",16);
280         &movups ($inout0,&QWP(0,$inp));
281         &movups ($inout1,&QWP(0x10,$inp));
282         &movups ($inout2,&QWP(0x20,$inp));
283         &call   ("_aesni_encrypt3");
284         &lea    ($inp,&DWP(0x30,$inp));
285         &movups (&QWP(0,$out),$inout0);
286         &mov    ($key,$key_);           # restore $key
287         &movups (&QWP(0x10,$out),$inout1);
288         &mov    ($rounds,$rounds_);     # restore $rounds
289         &movups (&QWP(0x20,$out),$inout2);
290         &lea    ($out,&DWP(0x30,$out));
291         &sub    ($len,0x30);
292         &ja     (&label("ecb_enc_loop3"));
293
294         &add    ($len,0x40);
295 &set_label("ecb_enc_tail");
296         &movups ($inout0,&QWP(0,$inp));
297         &cmp    ($len,0x20);
298         &jb     (&label("ecb_enc_one"));
299         &movups ($inout1,&QWP(0x10,$inp));
300         &je     (&label("ecb_enc_two"));
301         &movups ($inout2,&QWP(0x20,$inp));
302         &cmp    ($len,0x30);
303         &je     (&label("ecb_enc_three"));
304         &movups ($inout3,&QWP(0x30,$inp));
305         &call   ("_aesni_encrypt4");
306         &movups (&QWP(0,$out),$inout0);
307         &movups (&QWP(0x10,$out),$inout1);
308         &movups (&QWP(0x20,$out),$inout2);
309         &movups (&QWP(0x30,$out),$inout3);
310         jmp     (&label("ecb_ret"));
311
312 &set_label("ecb_enc_one",16);
313         if ($inline)
314         {   &aesni_inline_generate1("enc");     }
315         else
316         {   &call       ("_aesni_encrypt1");    }
317         &movups (&QWP(0,$out),$inout0);
318         &jmp    (&label("ecb_ret"));
319
320 &set_label("ecb_enc_two",16);
321         &pxor   ($inout2,$inout2);
322         &call   ("_aesni_encrypt3");
323         &movups (&QWP(0,$out),$inout0);
324         &movups (&QWP(0x10,$out),$inout1);
325         &jmp    (&label("ecb_ret"));
326
327 &set_label("ecb_enc_three",16);
328         &call   ("_aesni_encrypt3");
329         &movups (&QWP(0,$out),$inout0);
330         &movups (&QWP(0x10,$out),$inout1);
331         &movups (&QWP(0x20,$out),$inout2);
332         &jmp    (&label("ecb_ret"));
333 ######################################################################
334 &set_label("ecb_decrypt",16);
335         &cmp    ($len,0x40);
336         &jbe    (&label("ecb_dec_tail"));
337         &sub    ($len,0x40);
338         &jmp    (&label("ecb_dec_loop3"));
339
340 &set_label("ecb_dec_loop3",16);
341         &movups ($inout0,&QWP(0,$inp));
342         &movups ($inout1,&QWP(0x10,$inp));
343         &movups ($inout2,&QWP(0x20,$inp));
344         &call   ("_aesni_decrypt3");
345         &lea    ($inp,&DWP(0x30,$inp));
346         &movups (&QWP(0,$out),$inout0);
347         &mov    ($key,$key_);           # restore $key
348         &movups (&QWP(0x10,$out),$inout1);
349         &mov    ($rounds,$rounds_);     # restore $rounds
350         &movups (&QWP(0x20,$out),$inout2);
351         &lea    ($out,&DWP(0x30,$out));
352         &sub    ($len,0x30);
353         &ja     (&label("ecb_dec_loop3"));
354
355         &add    ($len,0x40);
356 &set_label("ecb_dec_tail");
357         &movups ($inout0,&QWP(0,$inp));
358         &cmp    ($len,0x20);
359         &jb     (&label("ecb_dec_one"));
360         &movups ($inout1,&QWP(0x10,$inp));
361         &je     (&label("ecb_dec_two"));
362         &movups ($inout2,&QWP(0x20,$inp));
363         &cmp    ($len,0x30);
364         &je     (&label("ecb_dec_three"));
365         &movups ($inout3,&QWP(0x30,$inp));
366         &call   ("_aesni_decrypt4");
367         &movups (&QWP(0,$out),$inout0);
368         &movups (&QWP(0x10,$out),$inout1);
369         &movups (&QWP(0x20,$out),$inout2);
370         &movups (&QWP(0x30,$out),$inout3);
371         &jmp    (&label("ecb_ret"));
372
373 &set_label("ecb_dec_one",16);
374         if ($inline)
375         {   &aesni_inline_generate1("dec");     }
376         else
377         {   &call       ("_aesni_decrypt1");    }
378         &movups (&QWP(0,$out),$inout0);
379         &jmp    (&label("ecb_ret"));
380
381 &set_label("ecb_dec_two",16);
382         &pxor   ($inout2,$inout2);
383         &call   ("_aesni_decrypt3");
384         &movups (&QWP(0,$out),$inout0);
385         &movups (&QWP(0x10,$out),$inout1);
386         &jmp    (&label("ecb_ret"));
387
388 &set_label("ecb_dec_three",16);
389         &call   ("_aesni_decrypt3");
390         &movups (&QWP(0,$out),$inout0);
391         &movups (&QWP(0x10,$out),$inout1);
392         &movups (&QWP(0x20,$out),$inout2);
393
394 &set_label("ecb_ret");
395 &function_end("aesni_ecb_encrypt");
396 \f
397 ######################################################################
398 # void aesni_ccm64_[en|de]crypt_blocks (const void *in, void *out,
399 #                         size_t blocks, const AES_KEY *key,
400 #                         const char *ivec,char *cmac);
401 #
402 # Handles only complete blocks, operates on 64-bit counter and
403 # does not update *ivec! Nor does it finalize CMAC value
404 # (see engine/eng_aesni.c for details)
405 #
406 &function_begin("aesni_ccm64_encrypt_blocks");
407         &mov    ($inp,&wparam(0));
408         &mov    ($out,&wparam(1));
409         &mov    ($len,&wparam(2));
410         &mov    ($key,&wparam(3));
411         &mov    ($rounds_,&wparam(4));
412         &mov    ($rounds,&wparam(5));
413         &mov    ($key_,"esp");
414         &sub    ("esp",60);
415         &and    ("esp",-16);                    # align stack
416         &mov    (&DWP(48,"esp"),$key_);
417
418         &movdqu ($ivec,&QWP(0,$rounds_));       # load ivec
419         &movdqu ($inout1,&QWP(0,$rounds));      # load cmac
420
421         # compose byte-swap control mask for pshufb on stack
422         &mov    (&DWP(0,"esp"),0x0c0d0e0f);
423         &mov    (&DWP(4,"esp"),0x08090a0b);
424         &mov    (&DWP(8,"esp"),0x04050607);
425         &mov    (&DWP(12,"esp"),0x00010203);
426
427         # compose counter increment vector on stack
428         &mov    ($rounds,1);
429         &xor    ($key_,$key_);
430         &mov    (&DWP(16,"esp"),$rounds);
431         &mov    (&DWP(20,"esp"),$key_);
432         &mov    (&DWP(24,"esp"),$key_);
433         &mov    (&DWP(28,"esp"),$key_);
434
435         &movdqa ($inout3,&QWP(0,"esp"));
436         &pshufb ($ivec,$inout3);                # keep iv in reverse order
437
438         &mov    ($rounds,&DWP(240,$key));
439         &mov    ($key_,$key);
440         &mov    ($rounds_,$rounds);
441         &movdqa ($inout0,$ivec);
442
443 &set_label("ccm64_enc_outer");
444         &movdqu ($in0,&QWP(0,$inp));
445         &pshufb ($inout0,$inout3);
446         &mov    ($key,$key_);
447         &mov    ($rounds,$rounds_);
448         &pxor   ($inout1,$in0);                 # cmac^=inp
449         &pxor   ($inout2,$inout2);
450
451         &call   ("_aesni_encrypt3");
452
453         &paddq  ($ivec,&QWP(16,"esp"));
454         &dec    ($len);
455         &lea    ($inp,&DWP(16,$inp));
456         &pxor   ($in0,$inout0);                 # inp^=E(ivec)
457         &movdqa ($inout0,$ivec);
458         &movdqu (&QWP(0,$out),$in0);
459         &lea    ($out,&DWP(16,$out));
460         &jnz    (&label("ccm64_enc_outer"));
461
462         &mov    ("esp",&DWP(48,"esp"));
463         &mov    ($out,&wparam(5));
464         &movdqu (&QWP(0,$out),$inout1);
465 &function_end("aesni_ccm64_encrypt_blocks");
466
467 &function_begin("aesni_ccm64_decrypt_blocks");
468         &mov    ($inp,&wparam(0));
469         &mov    ($out,&wparam(1));
470         &mov    ($len,&wparam(2));
471         &mov    ($key,&wparam(3));
472         &mov    ($rounds_,&wparam(4));
473         &mov    ($rounds,&wparam(5));
474         &mov    ($key_,"esp");
475         &sub    ("esp",60);
476         &and    ("esp",-16);                    # align stack
477         &mov    (&DWP(48,"esp"),$key_);
478
479         &movdqu ($ivec,&QWP(0,$rounds_));       # load ivec
480         &movdqu ($inout1,&QWP(0,$rounds));      # load cmac
481
482         # compose byte-swap control mask for pshufb on stack
483         &mov    (&DWP(0,"esp"),0x0c0d0e0f);
484         &mov    (&DWP(4,"esp"),0x08090a0b);
485         &mov    (&DWP(8,"esp"),0x04050607);
486         &mov    (&DWP(12,"esp"),0x00010203);
487
488         # compose counter increment vector on stack
489         &mov    ($rounds,1);
490         &xor    ($key_,$key_);
491         &mov    (&DWP(16,"esp"),$rounds);
492         &mov    (&DWP(20,"esp"),$key_);
493         &mov    (&DWP(24,"esp"),$key_);
494         &mov    (&DWP(28,"esp"),$key_);
495
496         &movdqa ($inout3,&QWP(0,"esp"));        # bswap mask
497         &movdqa ($inout0,$ivec);
498         &pshufb ($ivec,$inout3);                # keep iv in reverse order
499
500         &mov    ($rounds,&DWP(240,$key));
501         &mov    ($key_,$key);
502         &mov    ($rounds_,$rounds);
503
504         if ($inline)
505         {   &aesni_inline_generate1("enc");     }
506         else
507         {   &call       ("_aesni_encrypt1");    }
508
509 &set_label("ccm64_dec_outer");
510         &movdqu ($in0,&QWP(0,$inp));
511         &paddq  ($ivec,&QWP(16,"esp"));
512         &dec    ($len);
513         &lea    ($inp,&QWP(16,$inp));
514         &pxor   ($in0,$inout0);
515         &movdqa ($inout0,$ivec);
516         &mov    ($key,$key_);
517         &mov    ($rounds,$rounds_);
518         &pshufb ($inout0,$inout3);
519         &movdqu (&QWP(0,$out),$in0);
520         &lea    ($out,&DWP(16,$out));
521
522         &jz     (&label("ccm64_dec_break"));
523
524         &pxor   ($inout2,$inout2);
525         &call   ("_aesni_encrypt3");
526
527         &jmp    (&label("ccm64_dec_outer"));
528
529 &set_label("ccm64_dec_break",16);
530         if ($inline)
531         {   &aesni_inline_generate1("enc",$inout1);     }
532         else
533         {   &call       ("_aesni_encrypt1",$inout1);    }
534
535         &mov    ("esp",&DWP(48,"esp"));
536         &mov    ($out,&wparam(5));
537         &movdqu (&QWP(0,$out),$inout1);
538 &function_end("aesni_ccm64_decrypt_blocks");
539 \f
540 ######################################################################
541 # void aesni_ctr32_encrypt_blocks (const void *in, void *out,
542 #                         size_t blocks, const AES_KEY *key,
543 #                         const char *ivec);
544 #
545 # Handles only complete blocks, operates on 32-bit counter and
546 # does not update *ivec! (see engine/eng_aesni.c for details)
547 #
548 &function_begin("aesni_ctr32_encrypt_blocks");
549         &mov    ($inp,&wparam(0));
550         &mov    ($out,&wparam(1));
551         &mov    ($len,&wparam(2));
552         &mov    ($key,&wparam(3));
553         &mov    ($rounds_,&wparam(4));
554         &mov    ($key_,"esp");
555         &sub    ("esp",60);
556         &and    ("esp",-16);                    # align stack
557         &mov    (&DWP(48,"esp"),$key_);
558
559         &cmp    ($len,1);
560         &je     (&label("ctr32_one_shortcut"));
561
562         &movups ($inout3,&QWP(0,$rounds_));     # load ivec
563
564         # compose byte-swap control mask for pshufb on stack
565         &mov    (&DWP(0,"esp"),0x0c0d0e0f);
566         &mov    (&DWP(4,"esp"),0x08090a0b);
567         &mov    (&DWP(8,"esp"),0x04050607);
568         &mov    (&DWP(12,"esp"),0x00010203);
569
570         # compose counter increment vector on stack
571         &mov    ($rounds,3);
572         &xor    ($key_,$key_);
573         &mov    (&DWP(16,"esp"),$rounds);
574         &mov    (&DWP(20,"esp"),$rounds);
575         &mov    (&DWP(24,"esp"),$rounds);
576         &mov    (&DWP(28,"esp"),$key_);
577
578         &pextrd ($rounds_,$inout3,3);           # pull 32-bit counter
579         &pinsrd ($inout3,$key_,3);              # wipe 32-bit counter
580
581         &mov    ($rounds,&DWP(240,$key));       # key->rounds
582         &movdqa ($rndkey0,&QWP(0,"esp"));       # load byte-swap mask
583
584         # $ivec is vector of 3 32-bit counters
585         &pxor   ($ivec,$ivec);
586         &bswap  ($rounds_);
587         &pinsrd ($ivec,$rounds_,0);
588         &inc    ($rounds_);
589         &pinsrd ($ivec,$rounds_,1);
590         &inc    ($rounds_);
591         &pinsrd ($ivec,$rounds_,2);
592         &pshufb ($ivec,$rndkey0);               # byte swap
593
594         &cmp    ($len,4);
595         &jbe    (&label("ctr32_tail"));
596         &movdqa (&QWP(32,"esp"),$inout3);       # save counter-less ivec
597         &mov    ($rounds_,$rounds);
598         &mov    ($key_,$key);
599         &sub    ($len,4);
600         &jmp    (&label("ctr32_loop3"));
601
602 &set_label("ctr32_loop3",16);
603         &pshufd ($inout0,$ivec,3<<6);           # place counter to upper dword
604         &pshufd ($inout1,$ivec,2<<6);
605         &por    ($inout0,$inout3);              # merge counter-less ivec
606         &pshufd ($inout2,$ivec,1<<6);
607         &por    ($inout1,$inout3);
608         &por    ($inout2,$inout3);
609
610         # inline _aesni_encrypt3 and interleave last round
611         # with own code...
612
613         &$movekey       ($rndkey0,&QWP(0,$key));
614         &shr            ($rounds,1);
615         &$movekey       ($rndkey1,&QWP(16,$key));
616         &lea            ($key,&DWP(32,$key));
617         &pxor           ($inout0,$rndkey0);
618         &pxor           ($inout1,$rndkey0);
619         &pxor           ($inout2,$rndkey0);
620         &$movekey       ($rndkey0,&QWP(0,$key));
621
622 &set_label("ctr32_enc_loop3");
623         &aesenc         ($inout0,$rndkey1);
624         &aesenc         ($inout1,$rndkey1);
625         &dec            ($rounds);
626         &aesenc         ($inout2,$rndkey1);
627         &$movekey       ($rndkey1,&QWP(16,$key));
628         &aesenc         ($inout0,$rndkey0);
629         &aesenc         ($inout1,$rndkey0);
630         &lea            ($key,&DWP(32,$key));
631         &aesenc         ($inout2,$rndkey0);
632         &$movekey       ($rndkey0,&QWP(0,$key));
633         &jnz            (&label("ctr32_enc_loop3"));
634
635         &aesenc         ($inout0,$rndkey1);
636         &aesenc         ($inout1,$rndkey1);
637         &aesenc         ($inout2,$rndkey1);
638         &movdqa         ($rndkey1,&QWP(0,"esp"));       # load byte-swap mask
639
640         &aesenclast     ($inout0,$rndkey0);
641         &pshufb         ($ivec,$rndkey1);               # byte swap
642         &movdqu         ($in0,&QWP(0,$inp));
643         &aesenclast     ($inout1,$rndkey0);
644         &paddd          ($ivec,&QWP(16,"esp"));         # counter increment
645         &movdqu         ($in1,&QWP(0x10,$inp));
646         &aesenclast     ($inout2,$rndkey0);
647         &pshufb         ($ivec,$rndkey1);               # byte swap
648         &movdqu         ($rndkey0,&QWP(0x20,$inp));
649         &lea            ($inp,&DWP(0x30,$inp));
650
651         &pxor   ($in0,$inout0);
652         &mov    ($key,$key_);
653         &pxor   ($in1,$inout1);
654         &movdqu (&QWP(0,$out),$in0);
655         &pxor   ($rndkey0,$inout2);
656         &movdqu (&QWP(0x10,$out),$in1);
657         &movdqu (&QWP(0x20,$out),$rndkey0);
658         &movdqa ($inout3,&QWP(32,"esp"));       # load counter-less ivec
659
660         &sub    ($len,3);
661         &lea    ($out,&DWP(0x30,$out));
662         &mov    ($rounds,$rounds_);
663         &ja     (&label("ctr32_loop3"));
664
665         &pextrd ($rounds_,$ivec,1);             # might need last counter value
666         &add    ($len,4);
667         &bswap  ($rounds_);
668
669 &set_label("ctr32_tail");
670         &pshufd ($inout0,$ivec,3<<6);
671         &pshufd ($inout1,$ivec,2<<6);
672         &por    ($inout0,$inout3);
673         &cmp    ($len,2);
674         &jb     (&label("ctr32_one"));
675         &lea    ($rounds_,&DWP(1,$rounds_));
676         &pshufd ($inout2,$ivec,1<<6);
677         &por    ($inout1,$inout3);
678         &je     (&label("ctr32_two"));
679         &bswap  ($rounds_);
680         &por    ($inout2,$inout3);
681         &cmp    ($len,3);
682         &je     (&label("ctr32_three"));
683
684         &pinsrd ($inout3,$rounds_,3);           # compose last counter value
685
686         &call   ("_aesni_encrypt4");
687
688         &movdqu ($in0,&QWP(0,$inp));
689         &movdqu ($rndkey1,&QWP(0x10,$inp));
690         &pxor   ($in0,$inout0);
691         &movdqu ($rndkey0,&QWP(0x20,$inp));
692         &pxor   ($rndkey1,$inout1);
693         &movdqu ($ivec,&QWP(0x30,$inp));
694         &pxor   ($rndkey0,$inout2);
695         &movdqu (&QWP(0,$out),$in0);
696         &pxor   ($ivec,$inout3);
697         &movdqu (&QWP(0x10,$out),$rndkey1);
698         &movdqu (&QWP(0x20,$out),$rndkey0);
699         &movdqu (&QWP(0x30,$out),$ivec);
700         &jmp    (&label("ctr32_ret"));
701
702 &set_label("ctr32_one_shortcut",16);
703         &movdqu ($inout0,&QWP(0,$rounds_));     # load ivec
704         &mov    ($rounds,&DWP(240,$key));
705         
706 &set_label("ctr32_one");
707         if ($inline)
708         {   &aesni_inline_generate1("enc");     }
709         else
710         {   &call       ("_aesni_encrypt1");    }
711         &movdqu ($in0,&QWP(0,$inp));
712         &pxor   ($in0,$inout0);
713         &movdqu (&QWP(0,$out),$in0);
714         &jmp    (&label("ctr32_ret"));
715
716 &set_label("ctr32_two",16);
717         &pxor   ($inout2,$inout2);
718         &call   ("_aesni_encrypt3");
719         &movdqu ($in0,&QWP(0,$inp));
720         &movdqu ($in1,&QWP(0x10,$inp));
721         &pxor   ($in0,$inout0);
722         &pxor   ($in1,$inout1);
723         &movdqu (&QWP(0,$out),$in0);
724         &movdqu (&QWP(0x10,$out),$in1);
725         &jmp    (&label("ctr32_ret"));
726
727 &set_label("ctr32_three",16);
728         &call   ("_aesni_encrypt3");
729         &movdqu ($in0,&QWP(0,$inp));
730         &movdqu ($in1,&QWP(0x10,$inp));
731         &movdqu ($rndkey1,&QWP(0x20,$inp));
732         &pxor   ($in0,$inout0);
733         &pxor   ($in1,$inout1);
734         &movdqu (&QWP(0,$out),$in0);
735         &pxor   ($rndkey1,$inout2);
736         &movdqu (&QWP(0x10,$out),$in1);
737         &movdqu (&QWP(0x20,$out),$rndkey1);
738
739 &set_label("ctr32_ret");
740         &mov    ("esp",&DWP(48,"esp"));
741 &function_end("aesni_ctr32_encrypt_blocks");
742 }
743 \f
744 ######################################################################
745 # void $PREFIX_cbc_encrypt (const void *inp, void *out,
746 #                           size_t length, const AES_KEY *key,
747 #                           unsigned char *ivp,const int enc);
748 &function_begin("${PREFIX}_cbc_encrypt");
749         &mov    ($inp,&wparam(0));
750         &mov    ($out,&wparam(1));
751         &mov    ($len,&wparam(2));
752         &mov    ($key,&wparam(3));
753         &mov    ($key_,&wparam(4));
754         &test   ($len,$len);
755         &jz     (&label("cbc_ret"));
756
757         &cmp    (&wparam(5),0);
758         &movdqu ($ivec,&QWP(0,$key_));  # load IV
759         &mov    ($rounds,&DWP(240,$key));
760         &mov    ($key_,$key);           # backup $key
761         &mov    ($rounds_,$rounds);     # backup $rounds
762         &je     (&label("cbc_decrypt"));
763
764         &movdqa ($inout0,$ivec);
765         &cmp    ($len,16);
766         &jb     (&label("cbc_enc_tail"));
767         &sub    ($len,16);
768         &jmp    (&label("cbc_enc_loop"));
769
770 &set_label("cbc_enc_loop",16);
771         &movdqu ($ivec,&QWP(0,$inp));
772         &lea    ($inp,&DWP(16,$inp));
773         &pxor   ($inout0,$ivec);
774         if ($inline)
775         {   &aesni_inline_generate1("enc");     }
776         else
777         {   &call       ("_aesni_encrypt1");    }
778         &mov    ($rounds,$rounds_);     # restore $rounds
779         &mov    ($key,$key_);           # restore $key
780         &movups (&QWP(0,$out),$inout0); # store output
781         &lea    ($out,&DWP(16,$out));
782         &sub    ($len,16);
783         &jnc    (&label("cbc_enc_loop"));
784         &add    ($len,16);
785         &jnz    (&label("cbc_enc_tail"));
786         &movaps ($ivec,$inout0);
787         &jmp    (&label("cbc_ret"));
788
789 &set_label("cbc_enc_tail");
790         &mov    ("ecx",$len);           # zaps $rounds
791         &data_word(0xA4F3F689);         # rep movsb
792         &mov    ("ecx",16);             # zero tail
793         &sub    ("ecx",$len);
794         &xor    ("eax","eax");          # zaps $len
795         &data_word(0xAAF3F689);         # rep stosb
796         &lea    ($out,&DWP(-16,$out));  # rewind $out by 1 block
797         &mov    ($rounds,$rounds_);     # restore $rounds
798         &mov    ($inp,$out);            # $inp and $out are the same
799         &mov    ($key,$key_);           # restore $key
800         &jmp    (&label("cbc_enc_loop"));
801 ######################################################################
802 &set_label("cbc_decrypt",16);
803         &cmp    ($len,0x40);
804         &jbe    (&label("cbc_dec_tail"));
805         &sub    ($len,0x40);
806         &jmp    (&label("cbc_dec_loop3"));
807
808 &set_label("cbc_dec_loop3",16);
809         &movups ($inout0,&QWP(0,$inp));
810         &movups ($inout1,&QWP(0x10,$inp));
811         &movups ($inout2,&QWP(0x20,$inp));
812         &movaps ($in0,$inout0);
813         &movaps ($in1,$inout1);
814
815         &call   ("_aesni_decrypt3");
816
817         &pxor   ($inout0,$ivec);
818         &pxor   ($inout1,$in0);
819         &movdqu ($ivec,&QWP(0x20,$inp));
820         &lea    ($inp,&DWP(0x30,$inp));
821         &pxor   ($inout2,$in1);
822         &movdqu (&QWP(0,$out),$inout0);
823         &mov    ($rounds,$rounds_)      # restore $rounds
824         &movdqu (&QWP(0x10,$out),$inout1);
825         &mov    ($key,$key_);           # restore $key
826         &movdqu (&QWP(0x20,$out),$inout2);
827         &lea    ($out,&DWP(0x30,$out));
828         &sub    ($len,0x30);
829         &ja     (&label("cbc_dec_loop3"));
830
831         &add    ($len,0x40);
832 &set_label("cbc_dec_tail");
833         &movups ($inout0,&QWP(0,$inp));
834         &movaps ($in0,$inout0);
835         &cmp    ($len,0x10);
836         &jbe    (&label("cbc_dec_one"));
837         &movups ($inout1,&QWP(0x10,$inp));
838         &movaps ($in1,$inout1);
839         &cmp    ($len,0x20);
840         &jbe    (&label("cbc_dec_two"));
841         &movups ($inout2,&QWP(0x20,$inp));
842         &cmp    ($len,0x30);
843         &jbe    (&label("cbc_dec_three"));
844         &movups ($inout3,&QWP(0x30,$inp));
845         &call   ("_aesni_decrypt4");
846         &movdqu ($rndkey0,&QWP(0x10,$inp));
847         &movdqu ($rndkey1,&QWP(0x20,$inp));
848         &pxor   ($inout0,$ivec);
849         &pxor   ($inout1,$in0);
850         &movdqu ($ivec,&QWP(0x30,$inp));
851         &movdqu (&QWP(0,$out),$inout0);
852         &pxor   ($inout2,$rndkey0);
853         &pxor   ($inout3,$rndkey1);
854         &movdqu (&QWP(0x10,$out),$inout1);
855         &movdqu (&QWP(0x20,$out),$inout2);
856         &movdqa ($inout0,$inout3);
857         &lea    ($out,&DWP(0x30,$out));
858         &jmp    (&label("cbc_dec_tail_collected"));
859
860 &set_label("cbc_dec_one",16);
861         if ($inline)
862         {   &aesni_inline_generate1("dec");     }
863         else
864         {   &call       ("_aesni_decrypt1");    }
865         &pxor   ($inout0,$ivec);
866         &movdqa ($ivec,$in0);
867         &jmp    (&label("cbc_dec_tail_collected"));
868
869 &set_label("cbc_dec_two",16);
870         &pxor   ($inout2,$inout2);
871         &call   ("_aesni_decrypt3");
872         &pxor   ($inout0,$ivec);
873         &pxor   ($inout1,$in0);
874         &movdqu (&QWP(0,$out),$inout0);
875         &movdqa ($inout0,$inout1);
876         &movdqa ($ivec,$in1);
877         &lea    ($out,&DWP(0x10,$out));
878         &jmp    (&label("cbc_dec_tail_collected"));
879
880 &set_label("cbc_dec_three",16);
881         &call   ("_aesni_decrypt3");
882         &pxor   ($inout0,$ivec);
883         &pxor   ($inout1,$in0);
884         &pxor   ($inout2,$in1);
885         &movdqu (&QWP(0,$out),$inout0);
886         &movdqu (&QWP(0x10,$out),$inout1);
887         &movdqa ($inout0,$inout2);
888         &movdqu ($ivec,&QWP(0x20,$inp));
889         &lea    ($out,&DWP(0x20,$out));
890
891 &set_label("cbc_dec_tail_collected");
892         &and    ($len,15);
893         &jnz    (&label("cbc_dec_tail_partial"));
894         &movdqu (&QWP(0,$out),$inout0);
895         &jmp    (&label("cbc_ret"));
896
897 &set_label("cbc_dec_tail_partial",16);
898         &mov    ($key_,"esp");
899         &sub    ("esp",16);
900         &and    ("esp",-16);
901         &movdqa (&QWP(0,"esp"),$inout0);
902         &mov    ($inp,"esp");
903         &mov    ("ecx",$len);
904         &data_word(0xA4F3F689);         # rep movsb
905         &mov    ("esp",$key_);
906
907 &set_label("cbc_ret");
908         &mov    ($key_,&wparam(4));
909         &movups (&QWP(0,$key_),$ivec);  # output IV
910 &function_end("${PREFIX}_cbc_encrypt");
911 \f
912 ######################################################################
913 # Mechanical port from aesni-x86_64.pl.
914 #
915 # _aesni_set_encrypt_key is private interface,
916 # input:
917 #       "eax"   const unsigned char *userKey
918 #       $rounds int bits
919 #       $key    AES_KEY *key
920 # output:
921 #       "eax"   return code
922 #       $round  rounds
923
924 &function_begin_B("_aesni_set_encrypt_key");
925         &test   ("eax","eax");
926         &jz     (&label("bad_pointer"));
927         &test   ($key,$key);
928         &jz     (&label("bad_pointer"));
929
930         &movups ("xmm0",&QWP(0,"eax")); # pull first 128 bits of *userKey
931         &pxor   ("xmm4","xmm4");        # low dword of xmm4 is assumed 0
932         &lea    ($key,&DWP(16,$key));
933         &cmp    ($rounds,256);
934         &je     (&label("14rounds"));
935         &cmp    ($rounds,192);
936         &je     (&label("12rounds"));
937         &cmp    ($rounds,128);
938         &jne    (&label("bad_keybits"));
939
940 &set_label("10rounds",16);
941         &mov            ($rounds,9);
942         &$movekey       (&QWP(-16,$key),"xmm0");        # round 0
943         &aeskeygenassist("xmm1","xmm0",0x01);           # round 1
944         &call           (&label("key_128_cold"));
945         &aeskeygenassist("xmm1","xmm0",0x2);            # round 2
946         &call           (&label("key_128"));
947         &aeskeygenassist("xmm1","xmm0",0x04);           # round 3
948         &call           (&label("key_128"));
949         &aeskeygenassist("xmm1","xmm0",0x08);           # round 4
950         &call           (&label("key_128"));
951         &aeskeygenassist("xmm1","xmm0",0x10);           # round 5
952         &call           (&label("key_128"));
953         &aeskeygenassist("xmm1","xmm0",0x20);           # round 6
954         &call           (&label("key_128"));
955         &aeskeygenassist("xmm1","xmm0",0x40);           # round 7
956         &call           (&label("key_128"));
957         &aeskeygenassist("xmm1","xmm0",0x80);           # round 8
958         &call           (&label("key_128"));
959         &aeskeygenassist("xmm1","xmm0",0x1b);           # round 9
960         &call           (&label("key_128"));
961         &aeskeygenassist("xmm1","xmm0",0x36);           # round 10
962         &call           (&label("key_128"));
963         &$movekey       (&QWP(0,$key),"xmm0");
964         &mov            (&DWP(80,$key),$rounds);
965         &xor            ("eax","eax");
966         &ret();
967
968 &set_label("key_128",16);
969         &$movekey       (&QWP(0,$key),"xmm0");
970         &lea            ($key,&DWP(16,$key));
971 &set_label("key_128_cold");
972         &shufps         ("xmm4","xmm0",0b00010000);
973         &pxor           ("xmm0","xmm4");
974         &shufps         ("xmm4","xmm0",0b10001100,);
975         &pxor           ("xmm0","xmm4");
976         &pshufd         ("xmm1","xmm1",0b11111111);     # critical path
977         &pxor           ("xmm0","xmm1");
978         &ret();
979
980 &set_label("12rounds",16);
981         &movq           ("xmm2",&QWP(16,"eax"));        # remaining 1/3 of *userKey
982         &mov            ($rounds,11);
983         &$movekey       (&QWP(-16,$key),"xmm0")         # round 0
984         &aeskeygenassist("xmm1","xmm2",0x01);           # round 1,2
985         &call           (&label("key_192a_cold"));
986         &aeskeygenassist("xmm1","xmm2",0x02);           # round 2,3
987         &call           (&label("key_192b"));
988         &aeskeygenassist("xmm1","xmm2",0x04);           # round 4,5
989         &call           (&label("key_192a"));
990         &aeskeygenassist("xmm1","xmm2",0x08);           # round 5,6
991         &call           (&label("key_192b"));
992         &aeskeygenassist("xmm1","xmm2",0x10);           # round 7,8
993         &call           (&label("key_192a"));
994         &aeskeygenassist("xmm1","xmm2",0x20);           # round 8,9
995         &call           (&label("key_192b"));
996         &aeskeygenassist("xmm1","xmm2",0x40);           # round 10,11
997         &call           (&label("key_192a"));
998         &aeskeygenassist("xmm1","xmm2",0x80);           # round 11,12
999         &call           (&label("key_192b"));
1000         &$movekey       (&QWP(0,$key),"xmm0");
1001         &mov            (&DWP(48,$key),$rounds);
1002         &xor            ("eax","eax");
1003         &ret();
1004
1005 &set_label("key_192a",16);
1006         &$movekey       (&QWP(0,$key),"xmm0");
1007         &lea            ($key,&DWP(16,$key));
1008 &set_label("key_192a_cold",16);
1009         &movaps         ("xmm5","xmm2");
1010 &set_label("key_192b_warm");
1011         &shufps         ("xmm4","xmm0",0b00010000);
1012         &movaps         ("xmm3","xmm2");
1013         &pxor           ("xmm0","xmm4");
1014         &shufps         ("xmm4","xmm0",0b10001100);
1015         &pslldq         ("xmm3",4);
1016         &pxor           ("xmm0","xmm4");
1017         &pshufd         ("xmm1","xmm1",0b01010101);     # critical path
1018         &pxor           ("xmm2","xmm3");
1019         &pxor           ("xmm0","xmm1");
1020         &pshufd         ("xmm3","xmm0",0b11111111);
1021         &pxor           ("xmm2","xmm3");
1022         &ret();
1023
1024 &set_label("key_192b",16);
1025         &movaps         ("xmm3","xmm0");
1026         &shufps         ("xmm5","xmm0",0b01000100);
1027         &$movekey       (&QWP(0,$key),"xmm5");
1028         &shufps         ("xmm3","xmm2",0b01001110);
1029         &$movekey       (&QWP(16,$key),"xmm3");
1030         &lea            ($key,&DWP(32,$key));
1031         &jmp            (&label("key_192b_warm"));
1032
1033 &set_label("14rounds",16);
1034         &movups         ("xmm2",&QWP(16,"eax"));        # remaining half of *userKey
1035         &mov            ($rounds,13);
1036         &lea            ($key,&DWP(16,$key));
1037         &$movekey       (&QWP(-32,$key),"xmm0");        # round 0
1038         &$movekey       (&QWP(-16,$key),"xmm2");        # round 1
1039         &aeskeygenassist("xmm1","xmm2",0x01);           # round 2
1040         &call           (&label("key_256a_cold"));
1041         &aeskeygenassist("xmm1","xmm0",0x01);           # round 3
1042         &call           (&label("key_256b"));
1043         &aeskeygenassist("xmm1","xmm2",0x02);           # round 4
1044         &call           (&label("key_256a"));
1045         &aeskeygenassist("xmm1","xmm0",0x02);           # round 5
1046         &call           (&label("key_256b"));
1047         &aeskeygenassist("xmm1","xmm2",0x04);           # round 6
1048         &call           (&label("key_256a"));
1049         &aeskeygenassist("xmm1","xmm0",0x04);           # round 7
1050         &call           (&label("key_256b"));
1051         &aeskeygenassist("xmm1","xmm2",0x08);           # round 8
1052         &call           (&label("key_256a"));
1053         &aeskeygenassist("xmm1","xmm0",0x08);           # round 9
1054         &call           (&label("key_256b"));
1055         &aeskeygenassist("xmm1","xmm2",0x10);           # round 10
1056         &call           (&label("key_256a"));
1057         &aeskeygenassist("xmm1","xmm0",0x10);           # round 11
1058         &call           (&label("key_256b"));
1059         &aeskeygenassist("xmm1","xmm2",0x20);           # round 12
1060         &call           (&label("key_256a"));
1061         &aeskeygenassist("xmm1","xmm0",0x20);           # round 13
1062         &call           (&label("key_256b"));
1063         &aeskeygenassist("xmm1","xmm2",0x40);           # round 14
1064         &call           (&label("key_256a"));
1065         &$movekey       (&QWP(0,$key),"xmm0");
1066         &mov            (&DWP(16,$key),$rounds);
1067         &xor            ("eax","eax");
1068         &ret();
1069
1070 &set_label("key_256a",16);
1071         &$movekey       (&QWP(0,$key),"xmm2");
1072         &lea            ($key,&DWP(16,$key));
1073 &set_label("key_256a_cold");
1074         &shufps         ("xmm4","xmm0",0b00010000);
1075         &pxor           ("xmm0","xmm4");
1076         &shufps         ("xmm4","xmm0",0b10001100);
1077         &pxor           ("xmm0","xmm4");
1078         &pshufd         ("xmm1","xmm1",0b11111111);     # critical path
1079         &pxor           ("xmm0","xmm1");
1080         &ret();
1081
1082 &set_label("key_256b",16);
1083         &$movekey       (&QWP(0,$key),"xmm0");
1084         &lea            ($key,&DWP(16,$key));
1085
1086         &shufps         ("xmm4","xmm2",0b00010000);
1087         &pxor           ("xmm2","xmm4");
1088         &shufps         ("xmm4","xmm2",0b10001100);
1089         &pxor           ("xmm2","xmm4");
1090         &pshufd         ("xmm1","xmm1",0b10101010);     # critical path
1091         &pxor           ("xmm2","xmm1");
1092         &ret();
1093
1094 &set_label("bad_pointer",4);
1095         &mov    ("eax",-1);
1096         &ret    ();
1097 &set_label("bad_keybits",4);
1098         &mov    ("eax",-2);
1099         &ret    ();
1100 &function_end_B("_aesni_set_encrypt_key");
1101
1102 # int $PREFIX_set_encrypt_key (const unsigned char *userKey, int bits,
1103 #                              AES_KEY *key)
1104 &function_begin_B("${PREFIX}_set_encrypt_key");
1105         &mov    ("eax",&wparam(0));
1106         &mov    ($rounds,&wparam(1));
1107         &mov    ($key,&wparam(2));
1108         &call   ("_aesni_set_encrypt_key");
1109         &ret    ();
1110 &function_end_B("${PREFIX}_set_encrypt_key");
1111
1112 # int $PREFIX_set_decrypt_key (const unsigned char *userKey, int bits,
1113 #                              AES_KEY *key)
1114 &function_begin_B("${PREFIX}_set_decrypt_key");
1115         &mov    ("eax",&wparam(0));
1116         &mov    ($rounds,&wparam(1));
1117         &mov    ($key,&wparam(2));
1118         &call   ("_aesni_set_encrypt_key");
1119         &mov    ($key,&wparam(2));
1120         &shl    ($rounds,4)     # rounds-1 after _aesni_set_encrypt_key
1121         &test   ("eax","eax");
1122         &jnz    (&label("dec_key_ret"));
1123         &lea    ("eax",&DWP(16,$key,$rounds));  # end of key schedule
1124
1125         &$movekey       ("xmm0",&QWP(0,$key));  # just swap
1126         &$movekey       ("xmm1",&QWP(0,"eax"));
1127         &$movekey       (&QWP(0,"eax"),"xmm0");
1128         &$movekey       (&QWP(0,$key),"xmm1");
1129         &lea            ($key,&DWP(16,$key));
1130         &lea            ("eax",&DWP(-16,"eax"));
1131
1132 &set_label("dec_key_inverse");
1133         &$movekey       ("xmm0",&QWP(0,$key));  # swap and inverse
1134         &$movekey       ("xmm1",&QWP(0,"eax"));
1135         &aesimc         ("xmm0","xmm0");
1136         &aesimc         ("xmm1","xmm1");
1137         &lea            ($key,&DWP(16,$key));
1138         &lea            ("eax",&DWP(-16,"eax"));
1139         &$movekey       (&QWP(16,"eax"),"xmm0");
1140         &$movekey       (&QWP(-16,$key),"xmm1");
1141         &cmp            ("eax",$key);
1142         &ja             (&label("dec_key_inverse"));
1143
1144         &$movekey       ("xmm0",&QWP(0,$key));  # inverse middle
1145         &aesimc         ("xmm0","xmm0");
1146         &$movekey       (&QWP(0,$key),"xmm0");
1147
1148         &xor            ("eax","eax");          # return success
1149 &set_label("dec_key_ret");
1150         &ret    ();
1151 &function_end_B("${PREFIX}_set_decrypt_key");
1152 &asciz("AES for Intel AES-NI, CRYPTOGAMS by <appro\@openssl.org>");
1153
1154 &asm_finish();