Missing changes entry about OPENSSL_str[n]casecmp
[openssl.git] / engines / asm / e_padlock-x86_64.pl
1 #! /usr/bin/env perl
2 # Copyright 2011-2018 The OpenSSL Project Authors. All Rights Reserved.
3 #
4 # Licensed under the Apache License 2.0 (the "License").  You may not use
5 # this file except in compliance with the License.  You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
8
9
10 # ====================================================================
11 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
12 # project. The module is, however, dual licensed under OpenSSL and
13 # CRYPTOGAMS licenses depending on where you obtain it. For further
14 # details see http://www.openssl.org/~appro/cryptogams/.
15 # ====================================================================
16
17 # September 2011
18 #
19 # Assembler helpers for Padlock engine. See even e_padlock-x86.pl for
20 # details.
21
22 # $output is the last argument if it looks like a file (it has an extension)
23 # $flavour is the first argument if it doesn't look like a file
24 $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef;
25 $flavour = $#ARGV >= 0 && $ARGV[0] !~ m|\.| ? shift : undef;
26
27 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
28
29 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
30 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
31 ( $xlate="${dir}../../crypto/perlasm/x86_64-xlate.pl" and -f $xlate) or
32 die "can't locate x86_64-xlate.pl";
33
34 open OUT,"| \"$^X\" \"$xlate\" $flavour \"$output\""
35      or die "can't call $xlate: $!";
36 *STDOUT=*OUT;
37
38 $code=".text\n";
39
40 %PADLOCK_PREFETCH=(ecb=>128, cbc=>64, ctr32=>32);       # prefetch errata
41 $PADLOCK_CHUNK=512;     # Must be a power of 2 between 32 and 2^20
42
43 $ctx="%rdx";
44 $out="%rdi";
45 $inp="%rsi";
46 $len="%rcx";
47 $chunk="%rbx";
48
49 ($arg1,$arg2,$arg3,$arg4)=$win64?("%rcx","%rdx","%r8", "%r9") : # Win64 order
50                                  ("%rdi","%rsi","%rdx","%rcx"); # Unix order
51
52 $code.=<<___;
53 .globl  padlock_capability
54 .type   padlock_capability,\@abi-omnipotent
55 .align  16
56 padlock_capability:
57         mov     %rbx,%r8
58         xor     %eax,%eax
59         cpuid
60         xor     %eax,%eax
61         cmp     \$`"0x".unpack("H*",'tneC')`,%ebx
62         jne     .Lzhaoxin
63         cmp     \$`"0x".unpack("H*",'Hrua')`,%edx
64         jne     .Lnoluck
65         cmp     \$`"0x".unpack("H*",'slua')`,%ecx
66         jne     .Lnoluck
67         jmp     .LzhaoxinEnd
68 .Lzhaoxin:
69         cmp     \$`"0x".unpack("H*",'hS  ')`,%ebx
70         jne     .Lnoluck
71         cmp     \$`"0x".unpack("H*",'hgna')`,%edx
72         jne     .Lnoluck
73         cmp     \$`"0x".unpack("H*",'  ia')`,%ecx
74         jne     .Lnoluck
75 .LzhaoxinEnd:
76         mov     \$0xC0000000,%eax
77         cpuid
78         mov     %eax,%edx
79         xor     %eax,%eax
80         cmp     \$0xC0000001,%edx
81         jb      .Lnoluck
82         mov     \$0xC0000001,%eax
83         cpuid
84         mov     %edx,%eax
85         and     \$0xffffffef,%eax
86         or      \$0x10,%eax             # set Nano bit#4
87 .Lnoluck:
88         mov     %r8,%rbx
89         ret
90 .size   padlock_capability,.-padlock_capability
91
92 .globl  padlock_key_bswap
93 .type   padlock_key_bswap,\@abi-omnipotent,0
94 .align  16
95 padlock_key_bswap:
96         mov     240($arg1),%edx
97 .Lbswap_loop:
98         mov     ($arg1),%eax
99         bswap   %eax
100         mov     %eax,($arg1)
101         lea     4($arg1),$arg1
102         sub     \$1,%edx
103         jnz     .Lbswap_loop
104         ret
105 .size   padlock_key_bswap,.-padlock_key_bswap
106
107 .globl  padlock_verify_context
108 .type   padlock_verify_context,\@abi-omnipotent
109 .align  16
110 padlock_verify_context:
111         mov     $arg1,$ctx
112         pushf
113         lea     .Lpadlock_saved_context(%rip),%rax
114         call    _padlock_verify_ctx
115         lea     8(%rsp),%rsp
116         ret
117 .size   padlock_verify_context,.-padlock_verify_context
118
119 .type   _padlock_verify_ctx,\@abi-omnipotent
120 .align  16
121 _padlock_verify_ctx:
122         mov     8(%rsp),%r8
123         bt      \$30,%r8
124         jnc     .Lverified
125         cmp     (%rax),$ctx
126         je      .Lverified
127         pushf
128         popf
129 .Lverified:
130         mov     $ctx,(%rax)
131         ret
132 .size   _padlock_verify_ctx,.-_padlock_verify_ctx
133
134 .globl  padlock_reload_key
135 .type   padlock_reload_key,\@abi-omnipotent
136 .align  16
137 padlock_reload_key:
138         pushf
139         popf
140         ret
141 .size   padlock_reload_key,.-padlock_reload_key
142
143 .globl  padlock_aes_block
144 .type   padlock_aes_block,\@function,3
145 .align  16
146 padlock_aes_block:
147         mov     %rbx,%r8
148         mov     \$1,$len
149         lea     32($ctx),%rbx           # key
150         lea     16($ctx),$ctx           # control word
151         .byte   0xf3,0x0f,0xa7,0xc8     # rep xcryptecb
152         mov     %r8,%rbx
153         ret
154 .size   padlock_aes_block,.-padlock_aes_block
155
156 .globl  padlock_xstore
157 .type   padlock_xstore,\@function,2
158 .align  16
159 padlock_xstore:
160         mov     %esi,%edx
161         .byte   0x0f,0xa7,0xc0          # xstore
162         ret
163 .size   padlock_xstore,.-padlock_xstore
164
165 .globl  padlock_sha1_oneshot
166 .type   padlock_sha1_oneshot,\@function,3
167 .align  16
168 padlock_sha1_oneshot:
169         mov     %rdx,%rcx
170         mov     %rdi,%rdx               # put aside %rdi
171         movups  (%rdi),%xmm0            # copy-in context
172         sub     \$128+8,%rsp
173         mov     16(%rdi),%eax
174         movaps  %xmm0,(%rsp)
175         mov     %rsp,%rdi
176         mov     %eax,16(%rsp)
177         xor     %rax,%rax
178         .byte   0xf3,0x0f,0xa6,0xc8     # rep xsha1
179         movaps  (%rsp),%xmm0
180         mov     16(%rsp),%eax
181         add     \$128+8,%rsp
182         movups  %xmm0,(%rdx)            # copy-out context
183         mov     %eax,16(%rdx)
184         ret
185 .size   padlock_sha1_oneshot,.-padlock_sha1_oneshot
186
187 .globl  padlock_sha1_blocks
188 .type   padlock_sha1_blocks,\@function,3
189 .align  16
190 padlock_sha1_blocks:
191         mov     %rdx,%rcx
192         mov     %rdi,%rdx               # put aside %rdi
193         movups  (%rdi),%xmm0            # copy-in context
194         sub     \$128+8,%rsp
195         mov     16(%rdi),%eax
196         movaps  %xmm0,(%rsp)
197         mov     %rsp,%rdi
198         mov     %eax,16(%rsp)
199         mov     \$-1,%rax
200         .byte   0xf3,0x0f,0xa6,0xc8     # rep xsha1
201         movaps  (%rsp),%xmm0
202         mov     16(%rsp),%eax
203         add     \$128+8,%rsp
204         movups  %xmm0,(%rdx)            # copy-out context
205         mov     %eax,16(%rdx)
206         ret
207 .size   padlock_sha1_blocks,.-padlock_sha1_blocks
208
209 .globl  padlock_sha256_oneshot
210 .type   padlock_sha256_oneshot,\@function,3
211 .align  16
212 padlock_sha256_oneshot:
213         mov     %rdx,%rcx
214         mov     %rdi,%rdx               # put aside %rdi
215         movups  (%rdi),%xmm0            # copy-in context
216         sub     \$128+8,%rsp
217         movups  16(%rdi),%xmm1
218         movaps  %xmm0,(%rsp)
219         mov     %rsp,%rdi
220         movaps  %xmm1,16(%rsp)
221         xor     %rax,%rax
222         .byte   0xf3,0x0f,0xa6,0xd0     # rep xsha256
223         movaps  (%rsp),%xmm0
224         movaps  16(%rsp),%xmm1
225         add     \$128+8,%rsp
226         movups  %xmm0,(%rdx)            # copy-out context
227         movups  %xmm1,16(%rdx)
228         ret
229 .size   padlock_sha256_oneshot,.-padlock_sha256_oneshot
230
231 .globl  padlock_sha256_blocks
232 .type   padlock_sha256_blocks,\@function,3
233 .align  16
234 padlock_sha256_blocks:
235         mov     %rdx,%rcx
236         mov     %rdi,%rdx               # put aside %rdi
237         movups  (%rdi),%xmm0            # copy-in context
238         sub     \$128+8,%rsp
239         movups  16(%rdi),%xmm1
240         movaps  %xmm0,(%rsp)
241         mov     %rsp,%rdi
242         movaps  %xmm1,16(%rsp)
243         mov     \$-1,%rax
244         .byte   0xf3,0x0f,0xa6,0xd0     # rep xsha256
245         movaps  (%rsp),%xmm0
246         movaps  16(%rsp),%xmm1
247         add     \$128+8,%rsp
248         movups  %xmm0,(%rdx)            # copy-out context
249         movups  %xmm1,16(%rdx)
250         ret
251 .size   padlock_sha256_blocks,.-padlock_sha256_blocks
252
253 .globl  padlock_sha512_blocks
254 .type   padlock_sha512_blocks,\@function,3
255 .align  16
256 padlock_sha512_blocks:
257         mov     %rdx,%rcx
258         mov     %rdi,%rdx               # put aside %rdi
259         movups  (%rdi),%xmm0            # copy-in context
260         sub     \$128+8,%rsp
261         movups  16(%rdi),%xmm1
262         movups  32(%rdi),%xmm2
263         movups  48(%rdi),%xmm3
264         movaps  %xmm0,(%rsp)
265         mov     %rsp,%rdi
266         movaps  %xmm1,16(%rsp)
267         movaps  %xmm2,32(%rsp)
268         movaps  %xmm3,48(%rsp)
269         .byte   0xf3,0x0f,0xa6,0xe0     # rep xha512
270         movaps  (%rsp),%xmm0
271         movaps  16(%rsp),%xmm1
272         movaps  32(%rsp),%xmm2
273         movaps  48(%rsp),%xmm3
274         add     \$128+8,%rsp
275         movups  %xmm0,(%rdx)            # copy-out context
276         movups  %xmm1,16(%rdx)
277         movups  %xmm2,32(%rdx)
278         movups  %xmm3,48(%rdx)
279         ret
280 .size   padlock_sha512_blocks,.-padlock_sha512_blocks
281 ___
282
283 sub generate_mode {
284 my ($mode,$opcode) = @_;
285 # int padlock_$mode_encrypt(void *out, const void *inp,
286 #               struct padlock_cipher_data *ctx, size_t len);
287 $code.=<<___;
288 .globl  padlock_${mode}_encrypt
289 .type   padlock_${mode}_encrypt,\@function,4
290 .align  16
291 padlock_${mode}_encrypt:
292         push    %rbp
293         push    %rbx
294
295         xor     %eax,%eax
296         test    \$15,$ctx
297         jnz     .L${mode}_abort
298         test    \$15,$len
299         jnz     .L${mode}_abort
300         lea     .Lpadlock_saved_context(%rip),%rax
301         pushf
302         cld
303         call    _padlock_verify_ctx
304         lea     16($ctx),$ctx           # control word
305         xor     %eax,%eax
306         xor     %ebx,%ebx
307         testl   \$`1<<5`,($ctx)         # align bit in control word
308         jnz     .L${mode}_aligned
309         test    \$0x0f,$out
310         setz    %al                     # !out_misaligned
311         test    \$0x0f,$inp
312         setz    %bl                     # !inp_misaligned
313         test    %ebx,%eax
314         jnz     .L${mode}_aligned
315         neg     %rax
316         mov     \$$PADLOCK_CHUNK,$chunk
317         not     %rax                    # out_misaligned?-1:0
318         lea     (%rsp),%rbp
319         cmp     $chunk,$len
320         cmovc   $len,$chunk             # chunk=len>PADLOCK_CHUNK?PADLOCK_CHUNK:len
321         and     $chunk,%rax             # out_misaligned?chunk:0
322         mov     $len,$chunk
323         neg     %rax
324         and     \$$PADLOCK_CHUNK-1,$chunk       # chunk%=PADLOCK_CHUNK
325         lea     (%rax,%rbp),%rsp
326         mov     \$$PADLOCK_CHUNK,%rax
327         cmovz   %rax,$chunk                     # chunk=chunk?:PADLOCK_CHUNK
328 ___
329 $code.=<<___                            if ($mode eq "ctr32");
330 .L${mode}_reenter:
331         mov     -4($ctx),%eax           # pull 32-bit counter
332         bswap   %eax
333         neg     %eax
334         and     \$`$PADLOCK_CHUNK/16-1`,%eax
335         mov     \$$PADLOCK_CHUNK,$chunk
336         shl     \$4,%eax
337         cmovz   $chunk,%rax
338         cmp     %rax,$len
339         cmova   %rax,$chunk             # don't let counter cross PADLOCK_CHUNK
340         cmovbe  $len,$chunk
341 ___
342 $code.=<<___                            if ($PADLOCK_PREFETCH{$mode});
343         cmp     $chunk,$len
344         ja      .L${mode}_loop
345         mov     $inp,%rax               # check if prefetch crosses page
346         cmp     %rsp,%rbp
347         cmove   $out,%rax
348         add     $len,%rax
349         neg     %rax
350         and     \$0xfff,%rax            # distance to page boundary
351         cmp     \$$PADLOCK_PREFETCH{$mode},%rax
352         mov     \$-$PADLOCK_PREFETCH{$mode},%rax
353         cmovae  $chunk,%rax             # mask=distance<prefetch?-prefetch:-1
354         and     %rax,$chunk
355         jz      .L${mode}_unaligned_tail
356 ___
357 $code.=<<___;
358         jmp     .L${mode}_loop
359 .align  16
360 .L${mode}_loop:
361         cmp     $len,$chunk             # ctr32 artefact
362         cmova   $len,$chunk             # ctr32 artefact
363         mov     $out,%r8                # save parameters
364         mov     $inp,%r9
365         mov     $len,%r10
366         mov     $chunk,$len
367         mov     $chunk,%r11
368         test    \$0x0f,$out             # out_misaligned
369         cmovnz  %rsp,$out
370         test    \$0x0f,$inp             # inp_misaligned
371         jz      .L${mode}_inp_aligned
372         shr     \$3,$len
373         .byte   0xf3,0x48,0xa5          # rep movsq
374         sub     $chunk,$out
375         mov     $chunk,$len
376         mov     $out,$inp
377 .L${mode}_inp_aligned:
378         lea     -16($ctx),%rax          # ivp
379         lea     16($ctx),%rbx           # key
380         shr     \$4,$len
381         .byte   0xf3,0x0f,0xa7,$opcode  # rep xcrypt*
382 ___
383 $code.=<<___                            if ($mode !~ /ecb|ctr/);
384         movdqa  (%rax),%xmm0
385         movdqa  %xmm0,-16($ctx)         # copy [or refresh] iv
386 ___
387 $code.=<<___                            if ($mode eq "ctr32");
388         mov     -4($ctx),%eax           # pull 32-bit counter
389         test    \$0xffff0000,%eax
390         jnz     .L${mode}_no_carry
391         bswap   %eax
392         add     \$0x10000,%eax
393         bswap   %eax
394         mov     %eax,-4($ctx)
395 .L${mode}_no_carry:
396 ___
397 $code.=<<___;
398         mov     %r8,$out                # restore parameters
399         mov     %r11,$chunk
400         test    \$0x0f,$out
401         jz      .L${mode}_out_aligned
402         mov     $chunk,$len
403         lea     (%rsp),$inp
404         shr     \$3,$len
405         .byte   0xf3,0x48,0xa5          # rep movsq
406         sub     $chunk,$out
407 .L${mode}_out_aligned:
408         mov     %r9,$inp
409         mov     %r10,$len
410         add     $chunk,$out
411         add     $chunk,$inp
412         sub     $chunk,$len
413         mov     \$$PADLOCK_CHUNK,$chunk
414 ___
415                                         if (!$PADLOCK_PREFETCH{$mode}) {
416 $code.=<<___;
417         jnz     .L${mode}_loop
418 ___
419                                         } else {
420 $code.=<<___;
421         jz      .L${mode}_break
422         cmp     $chunk,$len
423         jae     .L${mode}_loop
424 ___
425 $code.=<<___                            if ($mode eq "ctr32");
426         mov     $len,$chunk
427         mov     $inp,%rax               # check if prefetch crosses page
428         cmp     %rsp,%rbp
429         cmove   $out,%rax
430         add     $len,%rax
431         neg     %rax
432         and     \$0xfff,%rax            # distance to page boundary
433         cmp     \$$PADLOCK_PREFETCH{$mode},%rax
434         mov     \$-$PADLOCK_PREFETCH{$mode},%rax
435         cmovae  $chunk,%rax
436         and     %rax,$chunk
437         jnz     .L${mode}_loop
438 ___
439 $code.=<<___;
440 .L${mode}_unaligned_tail:
441         xor     %eax,%eax
442         cmp     %rsp,%rbp
443         cmove   $len,%rax
444         mov     $out,%r8                # save parameters
445         mov     $len,$chunk
446         sub     %rax,%rsp               # alloca
447         shr     \$3,$len
448         lea     (%rsp),$out
449         .byte   0xf3,0x48,0xa5          # rep movsq
450         mov     %rsp,$inp
451         mov     %r8, $out               # restore parameters
452         mov     $chunk,$len
453         jmp     .L${mode}_loop
454 .align  16
455 .L${mode}_break:
456 ___
457                                         }
458 $code.=<<___;
459         cmp     %rbp,%rsp
460         je      .L${mode}_done
461
462         pxor    %xmm0,%xmm0
463         lea     (%rsp),%rax
464 .L${mode}_bzero:
465         movaps  %xmm0,(%rax)
466         lea     16(%rax),%rax
467         cmp     %rax,%rbp
468         ja      .L${mode}_bzero
469
470 .L${mode}_done:
471         lea     (%rbp),%rsp
472         jmp     .L${mode}_exit
473
474 .align  16
475 .L${mode}_aligned:
476 ___
477 $code.=<<___                            if ($mode eq "ctr32");
478         mov     -4($ctx),%eax           # pull 32-bit counter
479         bswap   %eax
480         neg     %eax
481         and     \$0xffff,%eax
482         mov     \$`16*0x10000`,$chunk
483         shl     \$4,%eax
484         cmovz   $chunk,%rax
485         cmp     %rax,$len
486         cmova   %rax,$chunk             # don't let counter cross 2^16
487         cmovbe  $len,$chunk
488         jbe     .L${mode}_aligned_skip
489
490 .L${mode}_aligned_loop:
491         mov     $len,%r10               # save parameters
492         mov     $chunk,$len
493         mov     $chunk,%r11
494
495         lea     -16($ctx),%rax          # ivp
496         lea     16($ctx),%rbx           # key
497         shr     \$4,$len                # len/=AES_BLOCK_SIZE
498         .byte   0xf3,0x0f,0xa7,$opcode  # rep xcrypt*
499
500         mov     -4($ctx),%eax           # pull 32-bit counter
501         bswap   %eax
502         add     \$0x10000,%eax
503         bswap   %eax
504         mov     %eax,-4($ctx)
505
506         mov     %r10,$len               # restore parameters
507         sub     %r11,$len
508         mov     \$`16*0x10000`,$chunk
509         jz      .L${mode}_exit
510         cmp     $chunk,$len
511         jae     .L${mode}_aligned_loop
512
513 .L${mode}_aligned_skip:
514 ___
515 $code.=<<___                            if ($PADLOCK_PREFETCH{$mode});
516         lea     ($inp,$len),%rbp
517         neg     %rbp
518         and     \$0xfff,%rbp            # distance to page boundary
519         xor     %eax,%eax
520         cmp     \$$PADLOCK_PREFETCH{$mode},%rbp
521         mov     \$$PADLOCK_PREFETCH{$mode}-1,%rbp
522         cmovae  %rax,%rbp
523         and     $len,%rbp               # remainder
524         sub     %rbp,$len
525         jz      .L${mode}_aligned_tail
526 ___
527 $code.=<<___;
528         lea     -16($ctx),%rax          # ivp
529         lea     16($ctx),%rbx           # key
530         shr     \$4,$len                # len/=AES_BLOCK_SIZE
531         .byte   0xf3,0x0f,0xa7,$opcode  # rep xcrypt*
532 ___
533 $code.=<<___                            if ($mode !~ /ecb|ctr/);
534         movdqa  (%rax),%xmm0
535         movdqa  %xmm0,-16($ctx)         # copy [or refresh] iv
536 ___
537 $code.=<<___                            if ($PADLOCK_PREFETCH{$mode});
538         test    %rbp,%rbp               # check remainder
539         jz      .L${mode}_exit
540
541 .L${mode}_aligned_tail:
542         mov     $out,%r8
543         mov     %rbp,$chunk
544         mov     %rbp,$len
545         lea     (%rsp),%rbp
546         sub     $len,%rsp
547         shr     \$3,$len
548         lea     (%rsp),$out
549         .byte   0xf3,0x48,0xa5          # rep movsq
550         lea     (%r8),$out
551         lea     (%rsp),$inp
552         mov     $chunk,$len
553         jmp     .L${mode}_loop
554 ___
555 $code.=<<___;
556 .L${mode}_exit:
557         mov     \$1,%eax
558         lea     8(%rsp),%rsp
559 .L${mode}_abort:
560         pop     %rbx
561         pop     %rbp
562         ret
563 .size   padlock_${mode}_encrypt,.-padlock_${mode}_encrypt
564 ___
565 }
566
567 &generate_mode("ecb",0xc8);
568 &generate_mode("cbc",0xd0);
569 &generate_mode("cfb",0xe0);
570 &generate_mode("ofb",0xe8);
571 &generate_mode("ctr32",0xd8);   # all 64-bit CPUs have working CTR...
572
573 $code.=<<___;
574 .asciz  "VIA Padlock x86_64 module, CRYPTOGAMS by <appro\@openssl.org>"
575 .align  16
576 .data
577 .align  8
578 .Lpadlock_saved_context:
579         .quad   0
580 ___
581 $code =~ s/\`([^\`]*)\`/eval($1)/gem;
582
583 print $code;
584
585 close STDOUT;