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 # ====================================================================
12 # "Teaser" Montgomery multiplication module for PowerPC. It's possible
13 # to gain a bit more by modulo-scheduling outer loop, then dedicated
14 # squaring procedure should give further 20% and code can be adapted
15 # for 32-bit application running on 64-bit CPU. As for the latter.
16 # It won't be able to achieve "native" 64-bit performance, because in
17 # 32-bit application context every addc instruction will have to be
18 # expanded as addc, twice right shift by 32 and finally adde, etc.
19 # So far RSA *sign* performance improvement over pre-bn_mul_mont asm
20 # for 64-bit application running on PPC970/G5 is:
29 if ($flavour =~ /32/) {
37 $LDU= "lwzu"; # load and update
38 $LDX= "lwzx"; # load indexed
40 $STU= "stwu"; # store and update
41 $STX= "stwx"; # store indexed
42 $STUX= "stwux"; # store indexed and update
43 $UMULL= "mullw"; # unsigned multiply low
44 $UMULH= "mulhwu"; # unsigned multiply high
45 $UCMP= "cmplw"; # unsigned compare
46 $SHRI= "srwi"; # unsigned shift right by immediate
49 } elsif ($flavour =~ /64/) {
56 # same as above, but 64-bit mnemonics...
58 $LDU= "ldu"; # load and update
59 $LDX= "ldx"; # load indexed
61 $STU= "stdu"; # store and update
62 $STX= "stdx"; # store indexed
63 $STUX= "stdux"; # store indexed and update
64 $UMULL= "mulld"; # unsigned multiply low
65 $UMULH= "mulhdu"; # unsigned multiply high
66 $UCMP= "cmpld"; # unsigned compare
67 $SHRI= "srdi"; # unsigned shift right by immediate
70 } else { die "nonsense $flavour"; }
72 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
73 ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or
74 ( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or
75 die "can't locate ppc-xlate.pl";
77 open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!";
87 $rp="r9"; # $rp is reassigned
91 # non-volatile registers
111 .globl .bn_mul_mont_int
115 mr $rp,r3 ; $rp is reassigned
119 $code.=<<___ if ($BNSZ==4);
120 cmpwi $num,32 ; longer key performance is not better
124 slwi $num,$num,`log($BNSZ)/log(2)`
126 addi $ovf,$num,`$FRAME+$RZONE`
127 subf $ovf,$ovf,$sp ; $sp-$ovf
128 and $ovf,$ovf,$tj ; minimize TLB usage
129 subf $ovf,$sp,$ovf ; $ovf-$sp
130 srwi $num,$num,`log($BNSZ)/log(2)`
133 $PUSH r14,`4*$SIZE_T`($sp)
134 $PUSH r15,`5*$SIZE_T`($sp)
135 $PUSH r16,`6*$SIZE_T`($sp)
136 $PUSH r17,`7*$SIZE_T`($sp)
137 $PUSH r18,`8*$SIZE_T`($sp)
138 $PUSH r19,`9*$SIZE_T`($sp)
139 $PUSH r20,`10*$SIZE_T`($sp)
140 $PUSH r21,`11*$SIZE_T`($sp)
141 $PUSH r22,`12*$SIZE_T`($sp)
142 $PUSH r23,`13*$SIZE_T`($sp)
143 $PUSH r24,`14*$SIZE_T`($sp)
144 $PUSH r25,`15*$SIZE_T`($sp)
146 $LD $n0,0($n0) ; pull n0[0] value
147 addi $num,$num,-2 ; adjust $num for counter register
149 $LD $m0,0($bp) ; m0=bp[0]
150 $LD $aj,0($ap) ; ap[0]
152 $UMULL $lo0,$aj,$m0 ; ap[0]*bp[0]
155 $LD $aj,$BNSZ($ap) ; ap[1]
156 $LD $nj,0($np) ; np[0]
158 $UMULL $m1,$lo0,$n0 ; "tp[0]"*n0
160 $UMULL $alo,$aj,$m0 ; ap[1]*bp[0]
163 $UMULL $lo1,$nj,$m1 ; np[0]*m1
165 $LD $nj,$BNSZ($np) ; np[1]
169 $UMULL $nlo,$nj,$m1 ; np[1]*m1
176 $LDX $aj,$ap,$j ; ap[j]
178 $LDX $nj,$np,$j ; np[j]
180 $UMULL $alo,$aj,$m0 ; ap[j]*bp[0]
184 $UMULL $nlo,$nj,$m1 ; np[j]*m1
185 addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[0]
188 $ST $lo1,0($tp) ; tp[j-1]
190 addi $j,$j,$BNSZ ; j++
191 addi $tp,$tp,$BNSZ ; tp++
199 addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[0]
201 $ST $lo1,0($tp) ; tp[j-1]
205 addze $ovf,$ovf ; upmost overflow bit
211 $LDX $m0,$bp,$i ; m0=bp[i]
212 $LD $aj,0($ap) ; ap[0]
214 $LD $tj,$FRAME($sp) ; tp[0]
215 $UMULL $lo0,$aj,$m0 ; ap[0]*bp[i]
217 $LD $aj,$BNSZ($ap) ; ap[1]
218 $LD $nj,0($np) ; np[0]
219 addc $lo0,$lo0,$tj ; ap[0]*bp[i]+tp[0]
220 $UMULL $alo,$aj,$m0 ; ap[j]*bp[i]
222 $UMULL $m1,$lo0,$n0 ; tp[0]*n0
224 $UMULL $lo1,$nj,$m1 ; np[0]*m1
226 $LD $nj,$BNSZ($np) ; np[1]
228 $UMULL $nlo,$nj,$m1 ; np[1]*m1
236 $LDX $aj,$ap,$j ; ap[j]
238 $LD $tj,$BNSZ($tp) ; tp[j]
240 $LDX $nj,$np,$j ; np[j]
242 $UMULL $alo,$aj,$m0 ; ap[j]*bp[i]
245 addc $lo0,$lo0,$tj ; ap[j]*bp[i]+tp[j]
246 $UMULL $nlo,$nj,$m1 ; np[j]*m1
249 addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[i]+tp[j]
250 addi $j,$j,$BNSZ ; j++
252 $ST $lo1,0($tp) ; tp[j-1]
253 addi $tp,$tp,$BNSZ ; tp++
256 $LD $tj,$BNSZ($tp) ; tp[j]
259 addc $lo0,$lo0,$tj ; ap[j]*bp[i]+tp[j]
264 addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[i]+tp[j]
266 $ST $lo1,0($tp) ; tp[j-1]
268 addic $ovf,$ovf,-1 ; move upmost overflow to XER[CA]
274 slwi $tj,$num,`log($BNSZ)/log(2)`
279 addi $num,$num,2 ; restore $num
280 subfc $j,$j,$j ; j=0 and "clear" XER[CA]
285 Lsub: $LDX $tj,$tp,$j
287 subfe $aj,$nj,$tj ; tp[j]-np[j]
294 subfe $ovf,$j,$ovf ; handle upmost overflow bit
297 or $ap,$ap,$np ; ap=borrow?tp:rp
300 Lcopy: ; copy or in-place refresh
303 $STX $j,$tp,$j ; zap at once
307 $POP r14,`4*$SIZE_T`($sp)
308 $POP r15,`5*$SIZE_T`($sp)
309 $POP r16,`6*$SIZE_T`($sp)
310 $POP r17,`7*$SIZE_T`($sp)
311 $POP r18,`8*$SIZE_T`($sp)
312 $POP r19,`9*$SIZE_T`($sp)
313 $POP r20,`10*$SIZE_T`($sp)
314 $POP r21,`11*$SIZE_T`($sp)
315 $POP r22,`12*$SIZE_T`($sp)
316 $POP r23,`13*$SIZE_T`($sp)
317 $POP r24,`14*$SIZE_T`($sp)
318 $POP r25,`15*$SIZE_T`($sp)
323 .asciz "Montgomery Multiplication for PPC, CRYPTOGAMS by <appro\@fy.chalmers.se>"
326 $code =~ s/\`([^\`]*)\`/eval $1/gem;