← Back to branch summary

~ubuntu-branches/ubuntu/lucid/openssl/lucid-proposed

« back to all changes in this revision

Viewing changes to crypto/sha/asm/sha1-x86_64.pl

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2009-06-13 18:15:46 UTC
  • mto: (11.1.5 squeeze)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20090613181546-vbfntai3b009dl1u
Tags: upstream-0.9.8k
Import upstream version 0.9.8k

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/sha/asm/sha1-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
# sha1_block procedure for x86_64.
 
11
#
 
12
# It was brought to my attention that on EM64T compiler-generated code
 
13
# was far behind 32-bit assembler implementation. This is unlike on
 
14
# Opteron where compiler-generated code was only 15% behind 32-bit
 
15
# assembler, which originally made it hard to motivate the effort.
 
16
# There was suggestion to mechanically translate 32-bit code, but I
 
17
# dismissed it, reasoning that x86_64 offers enough register bank
 
18
# capacity to fully utilize SHA-1 parallelism. Therefore this fresh
 
19
# implementation:-) However! While 64-bit code does performs better
 
20
# on Opteron, I failed to beat 32-bit assembler on EM64T core. Well,
 
21
# x86_64 does offer larger *addressable* bank, but out-of-order core
 
22
# reaches for even more registers through dynamic aliasing, and EM64T
 
23
# core must have managed to run-time optimize even 32-bit code just as
 
24
# good as 64-bit one. Performance improvement is summarized in the
 
25
# following table:
 
26
#
 
27
#               gcc 3.4         32-bit asm      cycles/byte
 
28
# Opteron       +45%            +20%            6.8
 
29
# Xeon P4       +65%            +0%             9.9
 
30
# Core2         +60%            +10%            7.0
 
31
 
 
32
$output=shift;
 
33
 
 
34
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
 
35
( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
 
36
( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
 
37
die "can't locate x86_64-xlate.pl";
 
38
 
 
39
open STDOUT,"| $^X $xlate $output";
 
40
 
 
41
$ctx="%rdi";    # 1st arg
 
42
$inp="%rsi";    # 2nd arg
 
43
$num="%rdx";    # 3rd arg
 
44
 
 
45
# reassign arguments in order to produce more compact code
 
46
$ctx="%r8";
 
47
$inp="%r9";
 
48
$num="%r10";
 
49
 
 
50
$xi="%eax";
 
51
$t0="%ebx";
 
52
$t1="%ecx";
 
53
$A="%edx";
 
54
$B="%esi";
 
55
$C="%edi";
 
56
$D="%ebp";
 
57
$E="%r11d";
 
58
$T="%r12d";
 
59
 
 
60
@V=($A,$B,$C,$D,$E,$T);
 
61
 
 
62
sub PROLOGUE {
 
63
my $func=shift;
 
64
$code.=<<___;
 
65
.globl  $func
 
66
.type   $func,\@function,3
 
67
.align  16
 
68
$func:
 
69
        push    %rbx
 
70
        push    %rbp
 
71
        push    %r12
 
72
        mov     %rsp,%rax
 
73
        mov     %rdi,$ctx       # reassigned argument
 
74
        sub     \$`8+16*4`,%rsp
 
75
        mov     %rsi,$inp       # reassigned argument
 
76
        and     \$-64,%rsp
 
77
        mov     %rdx,$num       # reassigned argument
 
78
        mov     %rax,`16*4`(%rsp)
 
79
 
 
80
        mov     0($ctx),$A
 
81
        mov     4($ctx),$B
 
82
        mov     8($ctx),$C
 
83
        mov     12($ctx),$D
 
84
        mov     16($ctx),$E
 
85
___
 
86
}
 
87
 
 
88
sub EPILOGUE {
 
89
my $func=shift;
 
90
$code.=<<___;
 
91
        mov     `16*4`(%rsp),%rsp
 
92
        pop     %r12
 
93
        pop     %rbp
 
94
        pop     %rbx
 
95
        ret
 
96
.size   $func,.-$func
 
97
___
 
98
}
 
99
 
 
100
sub BODY_00_19 {
 
101
my ($i,$a,$b,$c,$d,$e,$f,$host)=@_;
 
102
my $j=$i+1;
 
103
$code.=<<___ if ($i==0);
 
104
        mov     `4*$i`($inp),$xi        
 
105
        `"bswap $xi"    if(!defined($host))`
 
106
        mov     $xi,`4*$i`(%rsp)
 
107
___
 
108
$code.=<<___ if ($i<15);
 
109
        lea     0x5a827999($xi,$e),$f
 
110
        mov     $c,$t0
 
111
        mov     `4*$j`($inp),$xi
 
112
        mov     $a,$e
 
113
        xor     $d,$t0
 
114
        `"bswap $xi"    if(!defined($host))`    
 
115
        rol     \$5,$e
 
116
        and     $b,$t0
 
117
        mov     $xi,`4*$j`(%rsp)
 
118
        add     $e,$f
 
119
        xor     $d,$t0
 
120
        rol     \$30,$b
 
121
        add     $t0,$f
 
122
___
 
123
$code.=<<___ if ($i>=15);
 
124
        lea     0x5a827999($xi,$e),$f
 
125
        mov     `4*($j%16)`(%rsp),$xi
 
126
        mov     $c,$t0
 
127
        mov     $a,$e
 
128
        xor     `4*(($j+2)%16)`(%rsp),$xi
 
129
        xor     $d,$t0
 
130
        rol     \$5,$e
 
131
        xor     `4*(($j+8)%16)`(%rsp),$xi
 
132
        and     $b,$t0
 
133
        add     $e,$f
 
134
        xor     `4*(($j+13)%16)`(%rsp),$xi
 
135
        xor     $d,$t0
 
136
        rol     \$30,$b
 
137
        add     $t0,$f
 
138
        rol     \$1,$xi
 
139
        mov     $xi,`4*($j%16)`(%rsp)
 
140
___
 
141
}
 
142
 
 
143
sub BODY_20_39 {
 
144
my ($i,$a,$b,$c,$d,$e,$f)=@_;
 
145
my $j=$i+1;
 
146
my $K=($i<40)?0x6ed9eba1:0xca62c1d6;
 
147
$code.=<<___ if ($i<79);
 
148
        lea     $K($xi,$e),$f
 
149
        mov     `4*($j%16)`(%rsp),$xi
 
150
        mov     $c,$t0
 
151
        mov     $a,$e
 
152
        xor     `4*(($j+2)%16)`(%rsp),$xi
 
153
        xor     $b,$t0
 
154
        rol     \$5,$e
 
155
        xor     `4*(($j+8)%16)`(%rsp),$xi
 
156
        xor     $d,$t0
 
157
        add     $e,$f
 
158
        xor     `4*(($j+13)%16)`(%rsp),$xi
 
159
        rol     \$30,$b
 
160
        add     $t0,$f
 
161
        rol     \$1,$xi
 
162
___
 
163
$code.=<<___ if ($i<76);
 
164
        mov     $xi,`4*($j%16)`(%rsp)
 
165
___
 
166
$code.=<<___ if ($i==79);
 
167
        lea     $K($xi,$e),$f
 
168
        mov     $c,$t0
 
169
        mov     $a,$e
 
170
        xor     $b,$t0
 
171
        rol     \$5,$e
 
172
        xor     $d,$t0
 
173
        add     $e,$f
 
174
        rol     \$30,$b
 
175
        add     $t0,$f
 
176
___
 
177
}
 
178
 
 
179
sub BODY_40_59 {
 
180
my ($i,$a,$b,$c,$d,$e,$f)=@_;
 
181
my $j=$i+1;
 
182
$code.=<<___;
 
183
        lea     0x8f1bbcdc($xi,$e),$f
 
184
        mov     `4*($j%16)`(%rsp),$xi
 
185
        mov     $b,$t0
 
186
        mov     $b,$t1
 
187
        xor     `4*(($j+2)%16)`(%rsp),$xi
 
188
        mov     $a,$e
 
189
        and     $c,$t0
 
190
        xor     `4*(($j+8)%16)`(%rsp),$xi
 
191
        or      $c,$t1
 
192
        rol     \$5,$e
 
193
        xor     `4*(($j+13)%16)`(%rsp),$xi
 
194
        and     $d,$t1
 
195
        add     $e,$f
 
196
        rol     \$1,$xi
 
197
        or      $t1,$t0
 
198
        rol     \$30,$b
 
199
        mov     $xi,`4*($j%16)`(%rsp)
 
200
        add     $t0,$f
 
201
___
 
202
}
 
203
 
 
204
$code=".text\n";
 
205
 
 
206
&PROLOGUE("sha1_block_data_order");
 
207
$code.=".align  4\n.Lloop:\n";
 
208
for($i=0;$i<20;$i++)    { &BODY_00_19($i,@V); unshift(@V,pop(@V)); }
 
209
for(;$i<40;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 
210
for(;$i<60;$i++)        { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
 
211
for(;$i<80;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 
212
$code.=<<___;
 
213
        add     0($ctx),$E
 
214
        add     4($ctx),$T
 
215
        add     8($ctx),$A
 
216
        add     12($ctx),$B
 
217
        add     16($ctx),$C
 
218
        mov     $E,0($ctx)
 
219
        mov     $T,4($ctx)
 
220
        mov     $A,8($ctx)
 
221
        mov     $B,12($ctx)
 
222
        mov     $C,16($ctx)
 
223
 
 
224
        xchg    $E,$A   # mov   $E,$A
 
225
        xchg    $T,$B   # mov   $T,$B
 
226
        xchg    $E,$C   # mov   $A,$C
 
227
        xchg    $T,$D   # mov   $B,$D
 
228
                        # mov   $C,$E
 
229
        lea     `16*4`($inp),$inp
 
230
        sub     \$1,$num
 
231
        jnz     .Lloop
 
232
___
 
233
&EPILOGUE("sha1_block_data_order");
 
234
$code.=<<___;
 
235
.asciz  "SHA1 block transform for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
 
236
___
 
237
 
 
238
####################################################################
 
239
 
 
240
$code =~ s/\`([^\`]*)\`/eval $1/gem;
 
241
print $code;
 
242
close STDOUT;