a134127e8c654adeb676eef37b9ea07ba5b6fe77
[openssl.git] / crypto / rc4 / asm / rc4-x86_64.pl
1 #!/usr/bin/env perl
2 #
3 # ====================================================================
4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
5 # project. The module is, however, dual licensed under OpenSSL and
6 # CRYPTOGAMS licenses depending on where you obtain it. For further
7 # details see http://www.openssl.org/~appro/cryptogams/.
8 # ====================================================================
9 #
10 # 2.22x RC4 tune-up:-) It should be noted though that my hand [as in
11 # "hand-coded assembler"] doesn't stand for the whole improvement
12 # coefficient. It turned out that eliminating RC4_CHAR from config
13 # line results in ~40% improvement (yes, even for C implementation).
14 # Presumably it has everything to do with AMD cache architecture and
15 # RAW or whatever penalties. Once again! The module *requires* config
16 # line *without* RC4_CHAR! As for coding "secret," I bet on partial
17 # register arithmetics. For example instead of 'inc %r8; and $255,%r8'
18 # I simply 'inc %r8b'. Even though optimization manual discourages
19 # to operate on partial registers, it turned out to be the best bet.
20 # At least for AMD... How IA32E would perform remains to be seen...
21
22 # As was shown by Marc Bevand reordering of couple of load operations
23 # results in even higher performance gain of 3.3x:-) At least on
24 # Opteron... For reference, 1x in this case is RC4_CHAR C-code
25 # compiled with gcc 3.3.2, which performs at ~54MBps per 1GHz clock.
26 # Latter means that if you want to *estimate* what to expect from
27 # *your* Opteron, then multiply 54 by 3.3 and clock frequency in GHz.
28
29 # Intel P4 EM64T core was found to run the AMD64 code really slow...
30 # The only way to achieve comparable performance on P4 was to keep
31 # RC4_CHAR. Kind of ironic, huh? As it's apparently impossible to
32 # compose blended code, which would perform even within 30% marginal
33 # on either AMD and Intel platforms, I implement both cases. See
34 # rc4_skey.c for further details...
35
36 # P4 EM64T core appears to be "allergic" to 64-bit inc/dec. Replacing 
37 # those with add/sub results in 50% performance improvement of folded
38 # loop...
39
40 # As was shown by Zou Nanhai loop unrolling can improve Intel EM64T
41 # performance by >30% [unlike P4 32-bit case that is]. But this is
42 # provided that loads are reordered even more aggressively! Both code
43 # pathes, AMD64 and EM64T, reorder loads in essentially same manner
44 # as my IA-64 implementation. On Opteron this resulted in modest 5%
45 # improvement [I had to test it], while final Intel P4 performance
46 # achieves respectful 432MBps on 2.8GHz processor now. For reference.
47 # If executed on Xeon, current RC4_CHAR code-path is 2.7x faster than
48 # RC4_INT code-path. While if executed on Opteron, it's only 25%
49 # slower than the RC4_INT one [meaning that if CPU ยต-arch detection
50 # is not implemented, then this final RC4_CHAR code-path should be
51 # preferred, as it provides better *all-round* performance].
52
53 # Intel Core2 was observed to perform poorly on both code paths:-( It
54 # apparently suffers from some kind of partial register stall, which
55 # occurs in 64-bit mode only [as virtually identical 32-bit loop was
56 # observed to outperform 64-bit one by almost 50%]. Adding two movzb to
57 # cloop1 boosts its performance by 80%! This loop appears to be optimal
58 # fit for Core2 and therefore the code was modified to skip cloop8 on
59 # this CPU.
60
61 $flavour = shift;
62 $output  = shift;
63 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
64
65 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
66
67 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
68 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
69 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
70 die "can't locate x86_64-xlate.pl";
71
72 open STDOUT,"| $^X $xlate $flavour $output";
73
74 $dat="%rdi";        # arg1
75 $len="%rsi";        # arg2
76 $inp="%rdx";        # arg3
77 $out="%rcx";        # arg4
78
79 @XX=("%r8","%r10");
80 @TX=("%r9","%r11");
81 $YY="%r12";
82 $TY="%r13";
83
84 $code=<<___;
85 .section .note.GNU-stack,"",\@progbits
86 .text
87
88 .globl  RC4
89 .type   RC4,\@function,4
90 .align  16
91 RC4:    or      $len,$len
92         jne     .Lentry
93         ret
94 .Lentry:
95         push    %rbx
96         push    %r12
97         push    %r13
98 .Lprologue:
99
100         add     \$8,$dat
101         movl    -8($dat),$XX[0]#d
102         movl    -4($dat),$YY#d
103         cmpl    \$-1,256($dat)
104         je      .LRC4_CHAR
105         inc     $XX[0]#b
106         movl    ($dat,$XX[0],4),$TX[0]#d
107         test    \$-8,$len
108         jz      .Lloop1
109         jmp     .Lloop8
110 .align  16
111 .Lloop8:
112 ___
113 for ($i=0;$i<8;$i++) {
114 $code.=<<___;
115         add     $TX[0]#b,$YY#b
116         mov     $XX[0],$XX[1]
117         movl    ($dat,$YY,4),$TY#d
118         ror     \$8,%rax                        # ror is redundant when $i=0
119         inc     $XX[1]#b
120         movl    ($dat,$XX[1],4),$TX[1]#d
121         cmp     $XX[1],$YY
122         movl    $TX[0]#d,($dat,$YY,4)
123         cmove   $TX[0],$TX[1]
124         movl    $TY#d,($dat,$XX[0],4)
125         add     $TX[0]#b,$TY#b
126         movb    ($dat,$TY,4),%al
127 ___
128 push(@TX,shift(@TX)); push(@XX,shift(@XX));     # "rotate" registers
129 }
130 $code.=<<___;
131         ror     \$8,%rax
132         sub     \$8,$len
133
134         xor     ($inp),%rax
135         add     \$8,$inp
136         mov     %rax,($out)
137         add     \$8,$out
138
139         test    \$-8,$len
140         jnz     .Lloop8
141         cmp     \$0,$len
142         jne     .Lloop1
143         jmp     .Lexit
144
145 .align  16
146 .Lloop1:
147         add     $TX[0]#b,$YY#b
148         movl    ($dat,$YY,4),$TY#d
149         movl    $TX[0]#d,($dat,$YY,4)
150         movl    $TY#d,($dat,$XX[0],4)
151         add     $TY#b,$TX[0]#b
152         inc     $XX[0]#b
153         movl    ($dat,$TX[0],4),$TY#d
154         movl    ($dat,$XX[0],4),$TX[0]#d
155         xorb    ($inp),$TY#b
156         inc     $inp
157         movb    $TY#b,($out)
158         inc     $out
159         dec     $len
160         jnz     .Lloop1
161         jmp     .Lexit
162
163 .align  16
164 .LRC4_CHAR:
165         add     \$1,$XX[0]#b
166         movzb   ($dat,$XX[0]),$TX[0]#d
167         test    \$-8,$len
168         jz      .Lcloop1
169         cmpl    \$0,260($dat)
170         jnz     .Lcloop1
171         jmp     .Lcloop8
172 .align  16
173 .Lcloop8:
174         mov     ($inp),%eax
175         mov     4($inp),%ebx
176 ___
177 # unroll 2x4-wise, because 64-bit rotates kill Intel P4...
178 for ($i=0;$i<4;$i++) {
179 $code.=<<___;
180         add     $TX[0]#b,$YY#b
181         lea     1($XX[0]),$XX[1]
182         movzb   ($dat,$YY),$TY#d
183         movzb   $XX[1]#b,$XX[1]#d
184         movzb   ($dat,$XX[1]),$TX[1]#d
185         movb    $TX[0]#b,($dat,$YY)
186         cmp     $XX[1],$YY
187         movb    $TY#b,($dat,$XX[0])
188         jne     .Lcmov$i                        # Intel cmov is sloooow...
189         mov     $TX[0],$TX[1]
190 .Lcmov$i:
191         add     $TX[0]#b,$TY#b
192         xor     ($dat,$TY),%al
193         ror     \$8,%eax
194 ___
195 push(@TX,shift(@TX)); push(@XX,shift(@XX));     # "rotate" registers
196 }
197 for ($i=4;$i<8;$i++) {
198 $code.=<<___;
199         add     $TX[0]#b,$YY#b
200         lea     1($XX[0]),$XX[1]
201         movzb   ($dat,$YY),$TY#d
202         movzb   $XX[1]#b,$XX[1]#d
203         movzb   ($dat,$XX[1]),$TX[1]#d
204         movb    $TX[0]#b,($dat,$YY)
205         cmp     $XX[1],$YY
206         movb    $TY#b,($dat,$XX[0])
207         jne     .Lcmov$i                        # Intel cmov is sloooow...
208         mov     $TX[0],$TX[1]
209 .Lcmov$i:
210         add     $TX[0]#b,$TY#b
211         xor     ($dat,$TY),%bl
212         ror     \$8,%ebx
213 ___
214 push(@TX,shift(@TX)); push(@XX,shift(@XX));     # "rotate" registers
215 }
216 $code.=<<___;
217         lea     -8($len),$len
218         mov     %eax,($out)
219         lea     8($inp),$inp
220         mov     %ebx,4($out)
221         lea     8($out),$out
222
223         test    \$-8,$len
224         jnz     .Lcloop8
225         cmp     \$0,$len
226         jne     .Lcloop1
227         jmp     .Lexit
228 ___
229 $code.=<<___;
230 .align  16
231 .Lcloop1:
232         add     $TX[0]#b,$YY#b
233         movzb   ($dat,$YY),$TY#d
234         movb    $TX[0]#b,($dat,$YY)
235         movb    $TY#b,($dat,$XX[0])
236         add     $TX[0]#b,$TY#b
237         add     \$1,$XX[0]#b
238         movzb   $TY#b,$TY#d
239         movzb   $XX[0]#b,$XX[0]#d
240         movzb   ($dat,$TY),$TY#d
241         movzb   ($dat,$XX[0]),$TX[0]#d
242         xorb    ($inp),$TY#b
243         lea     1($inp),$inp
244         movb    $TY#b,($out)
245         lea     1($out),$out
246         sub     \$1,$len
247         jnz     .Lcloop1
248         jmp     .Lexit
249
250 .align  16
251 .Lexit:
252         sub     \$1,$XX[0]#b
253         movl    $XX[0]#d,-8($dat)
254         movl    $YY#d,-4($dat)
255
256         mov     (%rsp),%r13
257         mov     8(%rsp),%r12
258         mov     16(%rsp),%rbx
259         add     \$24,%rsp
260 .Lepilogue:
261         ret
262 .size   RC4,.-RC4
263 ___
264
265 $idx="%r8";
266 $ido="%r9";
267
268 $code.=<<___;
269 .extern OPENSSL_ia32cap_P
270 .globl  RC4_set_key
271 .type   RC4_set_key,\@function,3
272 .align  16
273 RC4_set_key:
274         lea     8($dat),$dat
275         lea     ($inp,$len),$inp
276         neg     $len
277         mov     $len,%rcx
278         xor     %eax,%eax
279         xor     $ido,$ido
280         xor     %r10,%r10
281         xor     %r11,%r11
282
283         mov     OPENSSL_ia32cap_P(%rip),$idx#d
284         bt      \$20,$idx#d
285         jnc     .Lw1stloop
286         bt      \$30,$idx#d
287         setc    $ido#b
288         mov     $ido#d,260($dat)
289         jmp     .Lc1stloop
290
291 .align  16
292 .Lw1stloop:
293         mov     %eax,($dat,%rax,4)
294         add     \$1,%al
295         jnc     .Lw1stloop
296
297         xor     $ido,$ido
298         xor     $idx,$idx
299 .align  16
300 .Lw2ndloop:
301         mov     ($dat,$ido,4),%r10d
302         add     ($inp,$len,1),$idx#b
303         add     %r10b,$idx#b
304         add     \$1,$len
305         mov     ($dat,$idx,4),%r11d
306         cmovz   %rcx,$len
307         mov     %r10d,($dat,$idx,4)
308         mov     %r11d,($dat,$ido,4)
309         add     \$1,$ido#b
310         jnc     .Lw2ndloop
311         jmp     .Lexit_key
312
313 .align  16
314 .Lc1stloop:
315         mov     %al,($dat,%rax)
316         add     \$1,%al
317         jnc     .Lc1stloop
318
319         xor     $ido,$ido
320         xor     $idx,$idx
321 .align  16
322 .Lc2ndloop:
323         mov     ($dat,$ido),%r10b
324         add     ($inp,$len),$idx#b
325         add     %r10b,$idx#b
326         add     \$1,$len
327         mov     ($dat,$idx),%r11b
328         jnz     .Lcnowrap
329         mov     %rcx,$len
330 .Lcnowrap:
331         mov     %r10b,($dat,$idx)
332         mov     %r11b,($dat,$ido)
333         add     \$1,$ido#b
334         jnc     .Lc2ndloop
335         movl    \$-1,256($dat)
336
337 .align  16
338 .Lexit_key:
339         xor     %eax,%eax
340         mov     %eax,-8($dat)
341         mov     %eax,-4($dat)
342         ret
343 .size   RC4_set_key,.-RC4_set_key
344
345 .globl  RC4_options
346 .type   RC4_options,\@abi-omnipotent
347 .align  16
348 RC4_options:
349         lea     .Lopts(%rip),%rax
350         mov     OPENSSL_ia32cap_P(%rip),%edx
351         bt      \$20,%edx
352         jnc     .Ldone
353         add     \$12,%rax
354         bt      \$30,%edx
355         jnc     .Ldone
356         add     \$13,%rax
357 .Ldone:
358         ret
359 .align  64
360 .Lopts:
361 .asciz  "rc4(8x,int)"
362 .asciz  "rc4(8x,char)"
363 .asciz  "rc4(1x,char)"
364 .asciz  "RC4 for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
365 .align  64
366 .size   RC4_options,.-RC4_options
367 ___
368
369 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
370 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
371 if ($win64) {
372 $rec="%rcx";
373 $frame="%rdx";
374 $context="%r8";
375 $disp="%r9";
376
377 $code.=<<___;
378 .extern __imp_RtlVirtualUnwind
379 .type   stream_se_handler,\@abi-omnipotent
380 .align  16
381 stream_se_handler:
382         push    %rsi
383         push    %rdi
384         push    %rbx
385         push    %rbp
386         push    %r12
387         push    %r13
388         push    %r14
389         push    %r15
390         pushfq
391         sub     \$64,%rsp
392
393         mov     120($context),%rax      # pull context->Rax
394         mov     248($context),%rbx      # pull context->Rip
395
396         lea     .Lprologue(%rip),%r10
397         cmp     %r10,%rbx               # context->Rip<prologue label
398         jb      .Lin_prologue
399
400         mov     152($context),%rax      # pull context->Rsp
401
402         lea     .Lepilogue(%rip),%r10
403         cmp     %r10,%rbx               # context->Rip>=epilogue label
404         jae     .Lin_prologue
405
406         lea     24(%rax),%rax
407
408         mov     -8(%rax),%rbx
409         mov     -16(%rax),%r12
410         mov     -24(%rax),%r13
411         mov     %rbx,144($context)      # restore context->Rbx
412         mov     %r12,216($context)      # restore context->R12
413         mov     %r13,224($context)      # restore context->R13
414
415 .Lin_prologue:
416         mov     8(%rax),%rdi
417         mov     16(%rax),%rsi
418         mov     %rax,152($context)      # restore context->Rsp
419         mov     %rsi,168($context)      # restore context->Rsi
420         mov     %rdi,176($context)      # restore context->Rdi
421
422         jmp     .Lcommon_seh_exit
423 .size   stream_se_handler,.-stream_se_handler
424
425 .type   key_se_handler,\@abi-omnipotent
426 .align  16
427 key_se_handler:
428         push    %rsi
429         push    %rdi
430         push    %rbx
431         push    %rbp
432         push    %r12
433         push    %r13
434         push    %r14
435         push    %r15
436         pushfq
437         sub     \$64,%rsp
438
439         mov     152($context),%rax      # pull context->Rsp
440         mov     8(%rax),%rdi
441         mov     16(%rax),%rsi
442         mov     %rsi,168($context)      # restore context->Rsi
443         mov     %rdi,176($context)      # restore context->Rdi
444
445 .Lcommon_seh_exit:
446
447         mov     40($disp),%rdi          # disp->ContextRecord
448         mov     $context,%rsi           # context
449         mov     \$154,%ecx              # sizeof(CONTEXT)
450         .long   0xa548f3fc              # cld; rep movsq
451
452         mov     $disp,%rsi
453         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
454         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
455         mov     0(%rsi),%r8             # arg3, disp->ControlPc
456         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
457         mov     40(%rsi),%r10           # disp->ContextRecord
458         lea     56(%rsi),%r11           # &disp->HandlerData
459         lea     24(%rsi),%r12           # &disp->EstablisherFrame
460         mov     %r10,32(%rsp)           # arg5
461         mov     %r11,40(%rsp)           # arg6
462         mov     %r12,48(%rsp)           # arg7
463         mov     %rcx,56(%rsp)           # arg8, (NULL)
464         call    *__imp_RtlVirtualUnwind(%rip)
465
466         mov     \$1,%eax                # ExceptionContinueSearch
467         add     \$64,%rsp
468         popfq
469         pop     %r15
470         pop     %r14
471         pop     %r13
472         pop     %r12
473         pop     %rbp
474         pop     %rbx
475         pop     %rdi
476         pop     %rsi
477         ret
478 .size   key_se_handler,.-key_se_handler
479
480 .section        .pdata
481 .align  4
482         .rva    .LSEH_begin_RC4
483         .rva    .LSEH_end_RC4
484         .rva    .LSEH_info_RC4
485
486         .rva    .LSEH_begin_RC4_set_key
487         .rva    .LSEH_end_RC4_set_key
488         .rva    .LSEH_info_RC4_set_key
489
490 .section        .xdata
491 .align  8
492 .LSEH_info_RC4:
493         .byte   9,0,0,0
494         .rva    stream_se_handler
495 .LSEH_info_RC4_set_key:
496         .byte   9,0,0,0
497         .rva    key_se_handler
498 ___
499 }
500
501 $code =~ s/#([bwd])/$1/gm;
502
503 print $code;
504
505 close STDOUT;