Adapt rc4-amd64.pl for Win64/AMD64 assembler.
[openssl.git] / crypto / rc4 / asm / rc4-amd64.pl
1 #!/usr/bin/env perl
2 #
3 # ====================================================================
4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
5 # project. Rights for redistribution and usage in source and binary
6 # forms are granted according to the OpenSSL license.
7 # ====================================================================
8 #
9 # 2.22x RC4 tune-up:-) It should be noted though that my hand [as in
10 # "hand-coded assembler"] doesn't stand for the whole improvement
11 # coefficient. It turned out that eliminating RC4_CHAR from config
12 # line results in ~40% improvement (yes, even for C implementation).
13 # Presumably it has everything to do with AMD cache architecture and
14 # RAW or whatever penalties. Once again! The module *requires* config
15 # line *without* RC4_CHAR! As for coding "secret," I bet on partial
16 # register arithmetics. For example instead 'inc %r8; and $255,%r8'
17 # I simply 'inc %r8b'. Even though optimization manual discourages
18 # to operate on partial registers, it turned out to be the best bet.
19 # At least for AMD... How IA32E would perform remains to be seen...
20
21 $output=shift;
22
23 $win64a=1 if ($output =~ /win64a.[s|asm]/);
24
25 open STDOUT,">$output" || die "can't open $output: $!";
26
27 if (defined($win64a)) {
28     $dat="%rcx";        # arg1
29     $len="%rdx";        # arg2
30     $inp="%rsi";        # r8, arg3 moves here
31     $out="%rdi";        # r9, arg4 moves here
32 } else {
33     $dat="%rdi";        # arg1
34     $len="%rsi";        # arg2
35     $inp="%rdx";        # arg3
36     $out="%rcx";        # arg4
37 }
38
39 $XX="%r10";
40 $TX="%r8";
41 $YY="%r11";
42 $TY="%r9";
43
44 sub PTR() {
45     my $ret=shift;
46     if (defined($win64a)) {
47         $ret =~ s/\[([\S]+)\+([\S]+)\]/[$2+$1]/g;   # [%rN+%rM*4]->[%rM*4+%rN]
48         $ret =~ s/:([^\[]+)\[([^\]]+)\]/:[$2+$1]/g; # :off[ea]->:[ea+off]
49     } else {
50         $ret =~ s/[\+\*]/,/g;           # [%rN+%rM*4]->[%rN,%rM,4]
51         $ret =~ s/\[([^\]]+)\]/($1)/g;  # [%rN]->(%rN)
52     }
53     $ret;
54 }
55
56 $code=<<___ if (!defined($win64a));
57 .text
58
59 .globl  RC4
60 .type   RC4,\@function
61 .align  16
62 RC4:    or      $len,$len
63         jne     .Lentry
64         repret
65 .Lentry:
66 ___
67 $code=<<___ if (defined($win64a));
68 TEXT    SEGMENT
69 PUBLIC  RC4
70 ALIGN   16
71 RC4     PROC NEAR
72         or      $len,$len
73         jne     .Lentry
74         repret
75 .Lentry:
76         push    %rdi
77         push    %rsi
78         sub     \$40,%rsp
79         mov     %r8,$inp
80         mov     %r9,$out
81 ___
82 $code.=<<___;
83         add     \$8,$dat
84         movl    `&PTR("DWORD:-8[$dat]")`,$XX#d
85         movl    `&PTR("DWORD:-4[$dat]")`,$YY#d
86         test    \$-8,$len
87         jz      .Lloop1
88 .align  16
89 .Lloop8:
90         movq    `&PTR("QWORD:[$inp]")`,%rax
91
92         inc     $XX#b
93         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
94         add     $TX#b,$YY#b
95         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
96         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
97         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
98         add     $TY#b,$TX#b
99         inc     $XX#b
100         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
101         xor     $TY,%rax
102 ___
103 for ($i=1;$i<=6;$i++) {
104 $code.=<<___;
105         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
106         add     $TX#b,$YY#b
107         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
108         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
109         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
110         add     $TY#b,$TX#b
111         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
112         shl     \$`8*$i`,$TY
113         inc     $XX#b
114         xor     $TY,%rax
115 ___
116 }
117 $code.=<<___;
118         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
119         add     $TX#b,$YY#b
120         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
121         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
122         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
123         sub     \$8,$len
124         add     $TY#b,$TX#b
125         add     \$8,$out
126         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
127         shl     \$56,$TY
128         add     \$8,$inp
129         xor     $TY,%rax
130
131         mov     %rax,`&PTR("QWORD:-8[$out]")`
132
133         test    \$-8,$len
134         jnz     .Lloop8
135         cmp     \$0,$len
136         jne     .Lloop1
137 .Lexit:
138         movl    $XX#d,`&PTR("DWORD:-8[$dat]")`
139         movl    $YY#d,`&PTR("DWORD:-4[$dat]")`
140 ___
141 $code.=<<___ if (defined($win64a));
142         add     \$40,%rsp
143         pop     %rsi
144         pop     %rdi
145 ___
146 $code.=<<___;
147         repret
148 .align  16
149 .Lloop1:
150         movzb   `&PTR("BYTE:[$inp]")`,%eax
151         inc     $XX#b
152         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
153         add     $TX#b,$YY#b
154         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
155         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
156         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
157         add     $TY#b,$TX#b
158         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
159         xor     $TY,%rax
160         inc     $inp
161         movb    %al,`&PTR("BYTE:[$out]")`
162         inc     $out
163         dec     $len
164         jnz     .Lloop1
165         jmp     .Lexit
166 ___
167 $code.=<<___ if (defined($win64a));
168 RC4     ENDP
169 TEXT    ENDS
170 END
171 ___
172 $code.=<<___ if (!defined($win64a));
173 .size   RC4,.-RC4
174 ___
175
176 $code =~ s/#([bwd])/$1/gm;
177 $code =~ s/\`([^\`]*)\`/eval $1/gem;
178
179 if (defined($win64a)) {
180     $code =~ s/\.align/ALIGN/gm;
181     $code =~ s/[\$%]//gm;
182     $code =~ s/\.L/\$L/gm;
183     $code =~ s/([\w]+)([\s]+)([\S]+),([\S]+)/$1$2$4,$3/gm;
184     $code =~ s/([QD]*WORD|BYTE):/$1 PTR/gm;
185     $code =~ s/mov[bwlq]/mov/gm;
186     $code =~ s/movzb/movzx/gm;
187     $code =~ s/repret/DB\t0F3h,0C3h/gm;
188 } else {
189     $code =~ s/([QD]*WORD|BYTE)://gm;
190     $code =~ s/repret/.byte\t0xF3,0xC3/gm;
191 }
192 print $code;