← Back to branch summary

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

« back to all changes in this revision

Viewing changes to crypto/bn/asm/s390x-mont.pl

  • Committer: Bazaar Package Importer
  • Author(s): Nicolas Valcárcel Scerpella (Canonical)
  • Date: 2009-12-06 20:16:24 UTC
  • mfrom: (11.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20091206201624-u126qjpqm2n2uuhu
Tags: 0.9.8k-7ubuntu1
https://launchpad.net/bugs/493392
* Merge from debian unstable, remaining changes (LP: #493392):
  - Link using -Bsymbolic-functions
  - Add support for lpia
  - Disable SSLv2 during compile
  - Ship documentation in openssl-doc, suggested by the package.
  - Use a different priority for libssl0.9.8/restart-services
    depending on whether a desktop, or server dist-upgrade is being
    performed.
  - Display a system restart required notification bubble on libssl0.9.8
    upgrade.
  - Replace duplicate files in the doc directory with symlinks.
  - Move runtime libraries to /lib, for the benefit of wpasupplicant
* Strip the patches out of the source into quilt patches
* Disable CVE-2009-3555.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/bn/asm/s390x-mont.pl
 
1
#!/usr/local/bin/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
# April 2007.
 
11
#
 
12
# Performance improvement over vanilla C code varies from 85% to 45%
 
13
# depending on key length and benchmark. Unfortunately in this context
 
14
# these are not very impressive results [for code that utilizes "wide"
 
15
# 64x64=128-bit multiplication, which is not commonly available to C
 
16
# programmers], at least hand-coded bn_asm.c replacement is known to
 
17
# provide 30-40% better results for longest keys. Well, on a second
 
18
# thought it's not very surprising, because z-CPUs are single-issue
 
19
# and _strictly_ in-order execution, while bn_mul_mont is more or less
 
20
# dependent on CPU ability to pipe-line instructions and have several
 
21
# of them "in-flight" at the same time. I mean while other methods,
 
22
# for example Karatsuba, aim to minimize amount of multiplications at
 
23
# the cost of other operations increase, bn_mul_mont aim to neatly
 
24
# "overlap" multiplications and the other operations [and on most
 
25
# platforms even minimize the amount of the other operations, in
 
26
# particular references to memory]. But it's possible to improve this
 
27
# module performance by implementing dedicated squaring code-path and
 
28
# possibly by unrolling loops...
 
29
 
 
30
# January 2009.
 
31
#
 
32
# Reschedule to minimize/avoid Address Generation Interlock hazard,
 
33
# make inner loops counter-based.
 
34
 
 
35
$mn0="%r0";
 
36
$num="%r1";
 
37
 
 
38
# int bn_mul_mont(
 
39
$rp="%r2";              # BN_ULONG *rp,
 
40
$ap="%r3";              # const BN_ULONG *ap,
 
41
$bp="%r4";              # const BN_ULONG *bp,
 
42
$np="%r5";              # const BN_ULONG *np,
 
43
$n0="%r6";              # const BN_ULONG *n0,
 
44
#$num="160(%r15)"       # int num);
 
45
 
 
46
$bi="%r2";      # zaps rp
 
47
$j="%r7";
 
48
 
 
49
$ahi="%r8";
 
50
$alo="%r9";
 
51
$nhi="%r10";
 
52
$nlo="%r11";
 
53
$AHI="%r12";
 
54
$NHI="%r13";
 
55
$count="%r14";
 
56
$sp="%r15";
 
57
 
 
58
$code.=<<___;
 
59
.text
 
60
.globl  bn_mul_mont
 
61
.type   bn_mul_mont,\@function
 
62
bn_mul_mont:
 
63
        lgf     $num,164($sp)   # pull $num
 
64
        sla     $num,3          # $num to enumerate bytes
 
65
        la      $bp,0($num,$bp)
 
66
 
 
67
        stg     %r2,16($sp)
 
68
 
 
69
        cghi    $num,16         #
 
70
        lghi    %r2,0           #
 
71
        blr     %r14            # if($num<16) return 0;
 
72
        cghi    $num,128        #
 
73
        bhr     %r14            # if($num>128) return 0;
 
74
 
 
75
        stmg    %r3,%r15,24($sp)
 
76
 
 
77
        lghi    $rp,-160-8      # leave room for carry bit
 
78
        lcgr    $j,$num         # -$num
 
79
        lgr     %r0,$sp
 
80
        la      $rp,0($rp,$sp)
 
81
        la      $sp,0($j,$rp)   # alloca
 
82
        stg     %r0,0($sp)      # back chain
 
83
 
 
84
        sra     $num,3          # restore $num
 
85
        la      $bp,0($j,$bp)   # restore $bp
 
86
        ahi     $num,-1         # adjust $num for inner loop
 
87
        lg      $n0,0($n0)      # pull n0
 
88
 
 
89
        lg      $bi,0($bp)
 
90
        lg      $alo,0($ap)
 
91
        mlgr    $ahi,$bi        # ap[0]*bp[0]
 
92
        lgr     $AHI,$ahi
 
93
 
 
94
        lgr     $mn0,$alo       # "tp[0]"*n0
 
95
        msgr    $mn0,$n0
 
96
 
 
97
        lg      $nlo,0($np)     #
 
98
        mlgr    $nhi,$mn0       # np[0]*m1
 
99
        algr    $nlo,$alo       # +="tp[0]"
 
100
        lghi    $NHI,0
 
101
        alcgr   $NHI,$nhi
 
102
 
 
103
        la      $j,8(%r0)       # j=1
 
104
        lr      $count,$num
 
105
 
 
106
.align  16
 
107
.L1st:
 
108
        lg      $alo,0($j,$ap)
 
109
        mlgr    $ahi,$bi        # ap[j]*bp[0]
 
110
        algr    $alo,$AHI
 
111
        lghi    $AHI,0
 
112
        alcgr   $AHI,$ahi
 
113
 
 
114
        lg      $nlo,0($j,$np)
 
115
        mlgr    $nhi,$mn0       # np[j]*m1
 
116
        algr    $nlo,$NHI
 
117
        lghi    $NHI,0
 
118
        alcgr   $nhi,$NHI       # +="tp[j]"
 
119
        algr    $nlo,$alo
 
120
        alcgr   $NHI,$nhi
 
121
 
 
122
        stg     $nlo,160-8($j,$sp)      # tp[j-1]=
 
123
        la      $j,8($j)        # j++
 
124
        brct    $count,.L1st
 
125
 
 
126
        algr    $NHI,$AHI
 
127
        lghi    $AHI,0
 
128
        alcgr   $AHI,$AHI       # upmost overflow bit
 
129
        stg     $NHI,160-8($j,$sp)
 
130
        stg     $AHI,160($j,$sp)
 
131
        la      $bp,8($bp)      # bp++
 
132
 
 
133
.Louter:
 
134
        lg      $bi,0($bp)      # bp[i]
 
135
        lg      $alo,0($ap)
 
136
        mlgr    $ahi,$bi        # ap[0]*bp[i]
 
137
        alg     $alo,160($sp)   # +=tp[0]
 
138
        lghi    $AHI,0
 
139
        alcgr   $AHI,$ahi
 
140
 
 
141
        lgr     $mn0,$alo
 
142
        msgr    $mn0,$n0        # tp[0]*n0
 
143
 
 
144
        lg      $nlo,0($np)     # np[0]
 
145
        mlgr    $nhi,$mn0       # np[0]*m1
 
146
        algr    $nlo,$alo       # +="tp[0]"
 
147
        lghi    $NHI,0
 
148
        alcgr   $NHI,$nhi
 
149
 
 
150
        la      $j,8(%r0)       # j=1
 
151
        lr      $count,$num
 
152
 
 
153
.align  16
 
154
.Linner:
 
155
        lg      $alo,0($j,$ap)
 
156
        mlgr    $ahi,$bi        # ap[j]*bp[i]
 
157
        algr    $alo,$AHI
 
158
        lghi    $AHI,0
 
159
        alcgr   $ahi,$AHI
 
160
        alg     $alo,160($j,$sp)# +=tp[j]
 
161
        alcgr   $AHI,$ahi
 
162
 
 
163
        lg      $nlo,0($j,$np)
 
164
        mlgr    $nhi,$mn0       # np[j]*m1
 
165
        algr    $nlo,$NHI
 
166
        lghi    $NHI,0
 
167
        alcgr   $nhi,$NHI
 
168
        algr    $nlo,$alo       # +="tp[j]"
 
169
        alcgr   $NHI,$nhi
 
170
 
 
171
        stg     $nlo,160-8($j,$sp)      # tp[j-1]=
 
172
        la      $j,8($j)        # j++
 
173
        brct    $count,.Linner
 
174
 
 
175
        algr    $NHI,$AHI
 
176
        lghi    $AHI,0
 
177
        alcgr   $AHI,$AHI
 
178
        alg     $NHI,160($j,$sp)# accumulate previous upmost overflow bit
 
179
        lghi    $ahi,0
 
180
        alcgr   $AHI,$ahi       # new upmost overflow bit
 
181
        stg     $NHI,160-8($j,$sp)
 
182
        stg     $AHI,160($j,$sp)
 
183
 
 
184
        la      $bp,8($bp)      # bp++
 
185
        clg     $bp,160+8+32($j,$sp)    # compare to &bp[num]
 
186
        jne     .Louter
 
187
 
 
188
        lg      $rp,160+8+16($j,$sp)    # reincarnate rp
 
189
        la      $ap,160($sp)
 
190
        ahi     $num,1          # restore $num, incidentally clears "borrow"
 
191
 
 
192
        la      $j,0(%r0)
 
193
        lr      $count,$num
 
194
.Lsub:  lg      $alo,0($j,$ap)
 
195
        slbg    $alo,0($j,$np)
 
196
        stg     $alo,0($j,$rp)
 
197
        la      $j,8($j)
 
198
        brct    $count,.Lsub
 
199
        lghi    $ahi,0
 
200
        slbgr   $AHI,$ahi       # handle upmost carry
 
201
 
 
202
        ngr     $ap,$AHI
 
203
        lghi    $np,-1
 
204
        xgr     $np,$AHI
 
205
        ngr     $np,$rp
 
206
        ogr     $ap,$np         # ap=borrow?tp:rp
 
207
 
 
208
        la      $j,0(%r0)
 
209
        lgr     $count,$num
 
210
.Lcopy: lg      $alo,0($j,$ap)  # copy or in-place refresh
 
211
        stg     $j,160($j,$sp)  # zap tp
 
212
        stg     $alo,0($j,$rp)
 
213
        la      $j,8($j)
 
214
        brct    $count,.Lcopy
 
215
 
 
216
        la      %r1,160+8+48($j,$sp)
 
217
        lmg     %r6,%r15,0(%r1)
 
218
        lghi    %r2,1           # signal "processed"
 
219
        br      %r14
 
220
.size   bn_mul_mont,.-bn_mul_mont
 
221
.string "Montgomery Multiplication for s390x, CRYPTOGAMS by <appro\@openssl.org>"
 
222
___
 
223
 
 
224
print $code;
 
225
close STDOUT;