| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env perl | |
| 2 # | |
| 3 # Implemented as a Perl wrapper as we want to support several different | |
| 4 # architectures with single file. We pick up the target based on the | |
| 5 # file name we are asked to generate. | |
| 6 # | |
| 7 # It should be noted though that this perl code is nothing like | |
| 8 # <openssl>/crypto/perlasm/x86*. In this case perl is used pretty much | |
| 9 # as pre-processor to cover for platform differences in name decoration, | |
| 10 # linker tables, 32-/64-bit instruction sets... | |
| 11 # | |
| 12 # As you might know there're several PowerPC ABI in use. Most notably | |
| 13 # Linux and AIX use different 32-bit ABIs. Good news are that these ABIs | |
| 14 # are similar enough to implement leaf(!) functions, which would be ABI | |
| 15 # neutral. And that's what you find here: ABI neutral leaf functions. | |
| 16 # In case you wonder what that is... | |
| 17 # | |
| 18 # AIX performance | |
| 19 # | |
| 20 # MEASUREMENTS WITH cc ON a 200 MhZ PowerPC 604e. | |
| 21 # | |
| 22 # The following is the performance of 32-bit compiler | |
| 23 # generated code: | |
| 24 # | |
| 25 # OpenSSL 0.9.6c 21 dec 2001 | |
| 26 # built on: Tue Jun 11 11:06:51 EDT 2002 | |
| 27 # options:bn(64,32) ... | |
| 28 #compiler: cc -DTHREADS -DAIX -DB_ENDIAN -DBN_LLONG -O3 | |
| 29 # sign verify sign/s verify/s | |
| 30 #rsa 512 bits 0.0098s 0.0009s 102.0 1170.6 | |
| 31 #rsa 1024 bits 0.0507s 0.0026s 19.7 387.5 | |
| 32 #rsa 2048 bits 0.3036s 0.0085s 3.3 117.1 | |
| 33 #rsa 4096 bits 2.0040s 0.0299s 0.5 33.4 | |
| 34 #dsa 512 bits 0.0087s 0.0106s 114.3 94.5 | |
| 35 #dsa 1024 bits 0.0256s 0.0313s 39.0 32.0 | |
| 36 # | |
| 37 # Same bechmark with this assembler code: | |
| 38 # | |
| 39 #rsa 512 bits 0.0056s 0.0005s 178.6 2049.2 | |
| 40 #rsa 1024 bits 0.0283s 0.0015s 35.3 674.1 | |
| 41 #rsa 2048 bits 0.1744s 0.0050s 5.7 201.2 | |
| 42 #rsa 4096 bits 1.1644s 0.0179s 0.9 55.7 | |
| 43 #dsa 512 bits 0.0052s 0.0062s 191.6 162.0 | |
| 44 #dsa 1024 bits 0.0149s 0.0180s 67.0 55.5 | |
| 45 # | |
| 46 # Number of operations increases by at almost 75% | |
| 47 # | |
| 48 # Here are performance numbers for 64-bit compiler | |
| 49 # generated code: | |
| 50 # | |
| 51 # OpenSSL 0.9.6g [engine] 9 Aug 2002 | |
| 52 # built on: Fri Apr 18 16:59:20 EDT 2003 | |
| 53 # options:bn(64,64) ... | |
| 54 # compiler: cc -DTHREADS -D_REENTRANT -q64 -DB_ENDIAN -O3 | |
| 55 # sign verify sign/s verify/s | |
| 56 #rsa 512 bits 0.0028s 0.0003s 357.1 3844.4 | |
| 57 #rsa 1024 bits 0.0148s 0.0008s 67.5 1239.7 | |
| 58 #rsa 2048 bits 0.0963s 0.0028s 10.4 353.0 | |
| 59 #rsa 4096 bits 0.6538s 0.0102s 1.5 98.1 | |
| 60 #dsa 512 bits 0.0026s 0.0032s 382.5 313.7 | |
| 61 #dsa 1024 bits 0.0081s 0.0099s 122.8 100.6 | |
| 62 # | |
| 63 # Same benchmark with this assembler code: | |
| 64 # | |
| 65 #rsa 512 bits 0.0020s 0.0002s 510.4 6273.7 | |
| 66 #rsa 1024 bits 0.0088s 0.0005s 114.1 2128.3 | |
| 67 #rsa 2048 bits 0.0540s 0.0016s 18.5 622.5 | |
| 68 #rsa 4096 bits 0.3700s 0.0058s 2.7 171.0 | |
| 69 #dsa 512 bits 0.0016s 0.0020s 610.7 507.1 | |
| 70 #dsa 1024 bits 0.0047s 0.0058s 212.5 173.2 | |
| 71 # | |
| 72 # Again, performance increases by at about 75% | |
| 73 # | |
| 74 # Mac OS X, Apple G5 1.8GHz (Note this is 32 bit code) | |
| 75 # OpenSSL 0.9.7c 30 Sep 2003 | |
| 76 # | |
| 77 # Original code. | |
| 78 # | |
| 79 #rsa 512 bits 0.0011s 0.0001s 906.1 11012.5 | |
| 80 #rsa 1024 bits 0.0060s 0.0003s 166.6 3363.1 | |
| 81 #rsa 2048 bits 0.0370s 0.0010s 27.1 982.4 | |
| 82 #rsa 4096 bits 0.2426s 0.0036s 4.1 280.4 | |
| 83 #dsa 512 bits 0.0010s 0.0012s 1038.1 841.5 | |
| 84 #dsa 1024 bits 0.0030s 0.0037s 329.6 269.7 | |
| 85 #dsa 2048 bits 0.0101s 0.0127s 98.9 78.6 | |
| 86 # | |
| 87 # Same benchmark with this assembler code: | |
| 88 # | |
| 89 #rsa 512 bits 0.0007s 0.0001s 1416.2 16645.9 | |
| 90 #rsa 1024 bits 0.0036s 0.0002s 274.4 5380.6 | |
| 91 #rsa 2048 bits 0.0222s 0.0006s 45.1 1589.5 | |
| 92 #rsa 4096 bits 0.1469s 0.0022s 6.8 449.6 | |
| 93 #dsa 512 bits 0.0006s 0.0007s 1664.2 1376.2 | |
| 94 #dsa 1024 bits 0.0018s 0.0023s 545.0 442.2 | |
| 95 #dsa 2048 bits 0.0061s 0.0075s 163.5 132.8 | |
| 96 # | |
| 97 # Performance increase of ~60% | |
| 98 # | |
| 99 # If you have comments or suggestions to improve code send | |
| 100 # me a note at schari@us.ibm.com | |
| 101 # | |
| 102 | |
| 103 $flavour = shift; | |
| 104 | |
| 105 if ($flavour =~ /32/) { | |
| 106 $BITS= 32; | |
| 107 $BNSZ= $BITS/8; | |
| 108 $ISA= "\"ppc\""; | |
| 109 | |
| 110 $LD= "lwz"; # load | |
| 111 $LDU= "lwzu"; # load and update | |
| 112 $ST= "stw"; # store | |
| 113 $STU= "stwu"; # store and update | |
| 114 $UMULL= "mullw"; # unsigned multiply low | |
| 115 $UMULH= "mulhwu"; # unsigned multiply high | |
| 116 $UDIV= "divwu"; # unsigned divide | |
| 117 $UCMPI= "cmplwi"; # unsigned compare with immediate | |
| 118 $UCMP= "cmplw"; # unsigned compare | |
| 119 $CNTLZ= "cntlzw"; # count leading zeros | |
| 120 $SHL= "slw"; # shift left | |
| 121 $SHR= "srw"; # unsigned shift right | |
| 122 $SHRI= "srwi"; # unsigned shift right by immediate | |
| 123 $SHLI= "slwi"; # shift left by immediate | |
| 124 $CLRU= "clrlwi"; # clear upper bits | |
| 125 $INSR= "insrwi"; # insert right | |
| 126 $ROTL= "rotlwi"; # rotate left by immediate | |
| 127 $TR= "tw"; # conditional trap | |
| 128 } elsif ($flavour =~ /64/) { | |
| 129 $BITS= 64; | |
| 130 $BNSZ= $BITS/8; | |
| 131 $ISA= "\"ppc64\""; | |
| 132 | |
| 133 # same as above, but 64-bit mnemonics... | |
| 134 $LD= "ld"; # load | |
| 135 $LDU= "ldu"; # load and update | |
| 136 $ST= "std"; # store | |
| 137 $STU= "stdu"; # store and update | |
| 138 $UMULL= "mulld"; # unsigned multiply low | |
| 139 $UMULH= "mulhdu"; # unsigned multiply high | |
| 140 $UDIV= "divdu"; # unsigned divide | |
| 141 $UCMPI= "cmpldi"; # unsigned compare with immediate | |
| 142 $UCMP= "cmpld"; # unsigned compare | |
| 143 $CNTLZ= "cntlzd"; # count leading zeros | |
| 144 $SHL= "sld"; # shift left | |
| 145 $SHR= "srd"; # unsigned shift right | |
| 146 $SHRI= "srdi"; # unsigned shift right by immediate | |
| 147 $SHLI= "sldi"; # shift left by immediate | |
| 148 $CLRU= "clrldi"; # clear upper bits | |
| 149 $INSR= "insrdi"; # insert right | |
| 150 $ROTL= "rotldi"; # rotate left by immediate | |
| 151 $TR= "td"; # conditional trap | |
| 152 } else { die "nonsense $flavour"; } | |
| 153 | |
| 154 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | |
| 155 ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or | |
| 156 ( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or | |
| 157 die "can't locate ppc-xlate.pl"; | |
| 158 | |
| 159 open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!"; | |
| 160 | |
| 161 $data=<<EOF; | |
| 162 #-------------------------------------------------------------------- | |
| 163 # | |
| 164 # | |
| 165 # | |
| 166 # | |
| 167 # File: ppc32.s | |
| 168 # | |
| 169 # Created by: Suresh Chari | |
| 170 # IBM Thomas J. Watson Research Library | |
| 171 # Hawthorne, NY | |
| 172 # | |
| 173 # | |
| 174 # Description: Optimized assembly routines for OpenSSL crypto | |
| 175 # on the 32 bitPowerPC platform. | |
| 176 # | |
| 177 # | |
| 178 # Version History | |
| 179 # | |
| 180 # 2. Fixed bn_add,bn_sub and bn_div_words, added comments, | |
| 181 # cleaned up code. Also made a single version which can | |
| 182 # be used for both the AIX and Linux compilers. See NOTE | |
| 183 # below. | |
| 184 # 12/05/03 Suresh Chari | |
| 185 # (with lots of help from) Andy Polyakov | |
| 186 ## | |
| 187 # 1. Initial version 10/20/02 Suresh Chari | |
| 188 # | |
| 189 # | |
| 190 # The following file works for the xlc,cc | |
| 191 # and gcc compilers. | |
| 192 # | |
| 193 # NOTE: To get the file to link correctly with the gcc compiler | |
| 194 # you have to change the names of the routines and remove | |
| 195 # the first .(dot) character. This should automatically | |
| 196 # be done in the build process. | |
| 197 # | |
| 198 # Hand optimized assembly code for the following routines | |
| 199 # | |
| 200 # bn_sqr_comba4 | |
| 201 # bn_sqr_comba8 | |
| 202 # bn_mul_comba4 | |
| 203 # bn_mul_comba8 | |
| 204 # bn_sub_words | |
| 205 # bn_add_words | |
| 206 # bn_div_words | |
| 207 # bn_sqr_words | |
| 208 # bn_mul_words | |
| 209 # bn_mul_add_words | |
| 210 # | |
| 211 # NOTE: It is possible to optimize this code more for | |
| 212 # specific PowerPC or Power architectures. On the Northstar | |
| 213 # architecture the optimizations in this file do | |
| 214 # NOT provide much improvement. | |
| 215 # | |
| 216 # If you have comments or suggestions to improve code send | |
| 217 # me a note at schari\@us.ibm.com | |
| 218 # | |
| 219 #-------------------------------------------------------------------------- | |
| 220 # | |
| 221 # Defines to be used in the assembly code. | |
| 222 # | |
| 223 #.set r0,0 # we use it as storage for value of 0 | |
| 224 #.set SP,1 # preserved | |
| 225 #.set RTOC,2 # preserved | |
| 226 #.set r3,3 # 1st argument/return value | |
| 227 #.set r4,4 # 2nd argument/volatile register | |
| 228 #.set r5,5 # 3rd argument/volatile register | |
| 229 #.set r6,6 # ... | |
| 230 #.set r7,7 | |
| 231 #.set r8,8 | |
| 232 #.set r9,9 | |
| 233 #.set r10,10 | |
| 234 #.set r11,11 | |
| 235 #.set r12,12 | |
| 236 #.set r13,13 # not used, nor any other "below" it... | |
| 237 | |
| 238 # Declare function names to be global | |
| 239 # NOTE: For gcc these names MUST be changed to remove | |
| 240 # the first . i.e. for example change ".bn_sqr_comba4" | |
| 241 # to "bn_sqr_comba4". This should be automatically done | |
| 242 # in the build. | |
| 243 | |
| 244 .globl .bn_sqr_comba4 | |
| 245 .globl .bn_sqr_comba8 | |
| 246 .globl .bn_mul_comba4 | |
| 247 .globl .bn_mul_comba8 | |
| 248 .globl .bn_sub_words | |
| 249 .globl .bn_add_words | |
| 250 .globl .bn_div_words | |
| 251 .globl .bn_sqr_words | |
| 252 .globl .bn_mul_words | |
| 253 .globl .bn_mul_add_words | |
| 254 | |
| 255 # .text section | |
| 256 | |
| 257 .machine "any" | |
| 258 | |
| 259 # | |
| 260 # NOTE: The following label name should be changed to | |
| 261 # "bn_sqr_comba4" i.e. remove the first dot | |
| 262 # for the gcc compiler. This should be automatically | |
| 263 # done in the build | |
| 264 # | |
| 265 | |
| 266 .align 4 | |
| 267 .bn_sqr_comba4: | |
| 268 # | |
| 269 # Optimized version of bn_sqr_comba4. | |
| 270 # | |
| 271 # void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a) | |
| 272 # r3 contains r | |
| 273 # r4 contains a | |
| 274 # | |
| 275 # Freely use registers r5,r6,r7,r8,r9,r10,r11 as follows: | |
| 276 # | |
| 277 # r5,r6 are the two BN_ULONGs being multiplied. | |
| 278 # r7,r8 are the results of the 32x32 giving 64 bit multiply. | |
| 279 # r9,r10, r11 are the equivalents of c1,c2, c3. | |
| 280 # Here's the assembly | |
| 281 # | |
| 282 # | |
| 283 xor r0,r0,r0 # set r0 = 0. Used in the addze | |
| 284 # instructions below | |
| 285 | |
| 286 #sqr_add_c(a,0,c1,c2,c3) | |
| 287 $LD r5,`0*$BNSZ`(r4) | |
| 288 $UMULL r9,r5,r5 | |
| 289 $UMULH r10,r5,r5 #in first iteration. No need | |
| 290 #to add since c1=c2=c3=0. | |
| 291 # Note c3(r11) is NOT set to 0 | |
| 292 # but will be. | |
| 293 | |
| 294 $ST r9,`0*$BNSZ`(r3) # r[0]=c1; | |
| 295 # sqr_add_c2(a,1,0,c2,c3,c1); | |
| 296 $LD r6,`1*$BNSZ`(r4) | |
| 297 $UMULL r7,r5,r6 | |
| 298 $UMULH r8,r5,r6 | |
| 299 | |
| 300 addc r7,r7,r7 # compute (r7,r8)=2*(r7,r8) | |
| 301 adde r8,r8,r8 | |
| 302 addze r9,r0 # catch carry if any. | |
| 303 # r9= r0(=0) and carry | |
| 304 | |
| 305 addc r10,r7,r10 # now add to temp result. | |
| 306 addze r11,r8 # r8 added to r11 which is 0 | |
| 307 addze r9,r9 | |
| 308 | |
| 309 $ST r10,`1*$BNSZ`(r3) #r[1]=c2; | |
| 310 #sqr_add_c(a,1,c3,c1,c2) | |
| 311 $UMULL r7,r6,r6 | |
| 312 $UMULH r8,r6,r6 | |
| 313 addc r11,r7,r11 | |
| 314 adde r9,r8,r9 | |
| 315 addze r10,r0 | |
| 316 #sqr_add_c2(a,2,0,c3,c1,c2) | |
| 317 $LD r6,`2*$BNSZ`(r4) | |
| 318 $UMULL r7,r5,r6 | |
| 319 $UMULH r8,r5,r6 | |
| 320 | |
| 321 addc r7,r7,r7 | |
| 322 adde r8,r8,r8 | |
| 323 addze r10,r10 | |
| 324 | |
| 325 addc r11,r7,r11 | |
| 326 adde r9,r8,r9 | |
| 327 addze r10,r10 | |
| 328 $ST r11,`2*$BNSZ`(r3) #r[2]=c3 | |
| 329 #sqr_add_c2(a,3,0,c1,c2,c3); | |
| 330 $LD r6,`3*$BNSZ`(r4) | |
| 331 $UMULL r7,r5,r6 | |
| 332 $UMULH r8,r5,r6 | |
| 333 addc r7,r7,r7 | |
| 334 adde r8,r8,r8 | |
| 335 addze r11,r0 | |
| 336 | |
| 337 addc r9,r7,r9 | |
| 338 adde r10,r8,r10 | |
| 339 addze r11,r11 | |
| 340 #sqr_add_c2(a,2,1,c1,c2,c3); | |
| 341 $LD r5,`1*$BNSZ`(r4) | |
| 342 $LD r6,`2*$BNSZ`(r4) | |
| 343 $UMULL r7,r5,r6 | |
| 344 $UMULH r8,r5,r6 | |
| 345 | |
| 346 addc r7,r7,r7 | |
| 347 adde r8,r8,r8 | |
| 348 addze r11,r11 | |
| 349 addc r9,r7,r9 | |
| 350 adde r10,r8,r10 | |
| 351 addze r11,r11 | |
| 352 $ST r9,`3*$BNSZ`(r3) #r[3]=c1 | |
| 353 #sqr_add_c(a,2,c2,c3,c1); | |
| 354 $UMULL r7,r6,r6 | |
| 355 $UMULH r8,r6,r6 | |
| 356 addc r10,r7,r10 | |
| 357 adde r11,r8,r11 | |
| 358 addze r9,r0 | |
| 359 #sqr_add_c2(a,3,1,c2,c3,c1); | |
| 360 $LD r6,`3*$BNSZ`(r4) | |
| 361 $UMULL r7,r5,r6 | |
| 362 $UMULH r8,r5,r6 | |
| 363 addc r7,r7,r7 | |
| 364 adde r8,r8,r8 | |
| 365 addze r9,r9 | |
| 366 | |
| 367 addc r10,r7,r10 | |
| 368 adde r11,r8,r11 | |
| 369 addze r9,r9 | |
| 370 $ST r10,`4*$BNSZ`(r3) #r[4]=c2 | |
| 371 #sqr_add_c2(a,3,2,c3,c1,c2); | |
| 372 $LD r5,`2*$BNSZ`(r4) | |
| 373 $UMULL r7,r5,r6 | |
| 374 $UMULH r8,r5,r6 | |
| 375 addc r7,r7,r7 | |
| 376 adde r8,r8,r8 | |
| 377 addze r10,r0 | |
| 378 | |
| 379 addc r11,r7,r11 | |
| 380 adde r9,r8,r9 | |
| 381 addze r10,r10 | |
| 382 $ST r11,`5*$BNSZ`(r3) #r[5] = c3 | |
| 383 #sqr_add_c(a,3,c1,c2,c3); | |
| 384 $UMULL r7,r6,r6 | |
| 385 $UMULH r8,r6,r6 | |
| 386 addc r9,r7,r9 | |
| 387 adde r10,r8,r10 | |
| 388 | |
| 389 $ST r9,`6*$BNSZ`(r3) #r[6]=c1 | |
| 390 $ST r10,`7*$BNSZ`(r3) #r[7]=c2 | |
| 391 blr | |
| 392 .long 0 | |
| 393 .byte 0,12,0x14,0,0,0,2,0 | |
| 394 .long 0 | |
| 395 | |
| 396 # | |
| 397 # NOTE: The following label name should be changed to | |
| 398 # "bn_sqr_comba8" i.e. remove the first dot | |
| 399 # for the gcc compiler. This should be automatically | |
| 400 # done in the build | |
| 401 # | |
| 402 | |
| 403 .align 4 | |
| 404 .bn_sqr_comba8: | |
| 405 # | |
| 406 # This is an optimized version of the bn_sqr_comba8 routine. | |
| 407 # Tightly uses the adde instruction | |
| 408 # | |
| 409 # | |
| 410 # void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a) | |
| 411 # r3 contains r | |
| 412 # r4 contains a | |
| 413 # | |
| 414 # Freely use registers r5,r6,r7,r8,r9,r10,r11 as follows: | |
| 415 # | |
| 416 # r5,r6 are the two BN_ULONGs being multiplied. | |
| 417 # r7,r8 are the results of the 32x32 giving 64 bit multiply. | |
| 418 # r9,r10, r11 are the equivalents of c1,c2, c3. | |
| 419 # | |
| 420 # Possible optimization of loading all 8 longs of a into registers | |
| 421 # doesnt provide any speedup | |
| 422 # | |
| 423 | |
| 424 xor r0,r0,r0 #set r0 = 0.Used in addze | |
| 425 #instructions below. | |
| 426 | |
| 427 #sqr_add_c(a,0,c1,c2,c3); | |
| 428 $LD r5,`0*$BNSZ`(r4) | |
| 429 $UMULL r9,r5,r5 #1st iteration: no carries. | |
| 430 $UMULH r10,r5,r5 | |
| 431 $ST r9,`0*$BNSZ`(r3) # r[0]=c1; | |
| 432 #sqr_add_c2(a,1,0,c2,c3,c1); | |
| 433 $LD r6,`1*$BNSZ`(r4) | |
| 434 $UMULL r7,r5,r6 | |
| 435 $UMULH r8,r5,r6 | |
| 436 | |
| 437 addc r10,r7,r10 #add the two register number | |
| 438 adde r11,r8,r0 # (r8,r7) to the three register | |
| 439 addze r9,r0 # number (r9,r11,r10).NOTE:r0=0 | |
| 440 | |
| 441 addc r10,r7,r10 #add the two register number | |
| 442 adde r11,r8,r11 # (r8,r7) to the three register | |
| 443 addze r9,r9 # number (r9,r11,r10). | |
| 444 | |
| 445 $ST r10,`1*$BNSZ`(r3) # r[1]=c2 | |
| 446 | |
| 447 #sqr_add_c(a,1,c3,c1,c2); | |
| 448 $UMULL r7,r6,r6 | |
| 449 $UMULH r8,r6,r6 | |
| 450 addc r11,r7,r11 | |
| 451 adde r9,r8,r9 | |
| 452 addze r10,r0 | |
| 453 #sqr_add_c2(a,2,0,c3,c1,c2); | |
| 454 $LD r6,`2*$BNSZ`(r4) | |
| 455 $UMULL r7,r5,r6 | |
| 456 $UMULH r8,r5,r6 | |
| 457 | |
| 458 addc r11,r7,r11 | |
| 459 adde r9,r8,r9 | |
| 460 addze r10,r10 | |
| 461 | |
| 462 addc r11,r7,r11 | |
| 463 adde r9,r8,r9 | |
| 464 addze r10,r10 | |
| 465 | |
| 466 $ST r11,`2*$BNSZ`(r3) #r[2]=c3 | |
| 467 #sqr_add_c2(a,3,0,c1,c2,c3); | |
| 468 $LD r6,`3*$BNSZ`(r4) #r6 = a[3]. r5 is already a[0]. | |
| 469 $UMULL r7,r5,r6 | |
| 470 $UMULH r8,r5,r6 | |
| 471 | |
| 472 addc r9,r7,r9 | |
| 473 adde r10,r8,r10 | |
| 474 addze r11,r0 | |
| 475 | |
| 476 addc r9,r7,r9 | |
| 477 adde r10,r8,r10 | |
| 478 addze r11,r11 | |
| 479 #sqr_add_c2(a,2,1,c1,c2,c3); | |
| 480 $LD r5,`1*$BNSZ`(r4) | |
| 481 $LD r6,`2*$BNSZ`(r4) | |
| 482 $UMULL r7,r5,r6 | |
| 483 $UMULH r8,r5,r6 | |
| 484 | |
| 485 addc r9,r7,r9 | |
| 486 adde r10,r8,r10 | |
| 487 addze r11,r11 | |
| 488 | |
| 489 addc r9,r7,r9 | |
| 490 adde r10,r8,r10 | |
| 491 addze r11,r11 | |
| 492 | |
| 493 $ST r9,`3*$BNSZ`(r3) #r[3]=c1; | |
| 494 #sqr_add_c(a,2,c2,c3,c1); | |
| 495 $UMULL r7,r6,r6 | |
| 496 $UMULH r8,r6,r6 | |
| 497 | |
| 498 addc r10,r7,r10 | |
| 499 adde r11,r8,r11 | |
| 500 addze r9,r0 | |
| 501 #sqr_add_c2(a,3,1,c2,c3,c1); | |
| 502 $LD r6,`3*$BNSZ`(r4) | |
| 503 $UMULL r7,r5,r6 | |
| 504 $UMULH r8,r5,r6 | |
| 505 | |
| 506 addc r10,r7,r10 | |
| 507 adde r11,r8,r11 | |
| 508 addze r9,r9 | |
| 509 | |
| 510 addc r10,r7,r10 | |
| 511 adde r11,r8,r11 | |
| 512 addze r9,r9 | |
| 513 #sqr_add_c2(a,4,0,c2,c3,c1); | |
| 514 $LD r5,`0*$BNSZ`(r4) | |
| 515 $LD r6,`4*$BNSZ`(r4) | |
| 516 $UMULL r7,r5,r6 | |
| 517 $UMULH r8,r5,r6 | |
| 518 | |
| 519 addc r10,r7,r10 | |
| 520 adde r11,r8,r11 | |
| 521 addze r9,r9 | |
| 522 | |
| 523 addc r10,r7,r10 | |
| 524 adde r11,r8,r11 | |
| 525 addze r9,r9 | |
| 526 $ST r10,`4*$BNSZ`(r3) #r[4]=c2; | |
| 527 #sqr_add_c2(a,5,0,c3,c1,c2); | |
| 528 $LD r6,`5*$BNSZ`(r4) | |
| 529 $UMULL r7,r5,r6 | |
| 530 $UMULH r8,r5,r6 | |
| 531 | |
| 532 addc r11,r7,r11 | |
| 533 adde r9,r8,r9 | |
| 534 addze r10,r0 | |
| 535 | |
| 536 addc r11,r7,r11 | |
| 537 adde r9,r8,r9 | |
| 538 addze r10,r10 | |
| 539 #sqr_add_c2(a,4,1,c3,c1,c2); | |
| 540 $LD r5,`1*$BNSZ`(r4) | |
| 541 $LD r6,`4*$BNSZ`(r4) | |
| 542 $UMULL r7,r5,r6 | |
| 543 $UMULH r8,r5,r6 | |
| 544 | |
| 545 addc r11,r7,r11 | |
| 546 adde r9,r8,r9 | |
| 547 addze r10,r10 | |
| 548 | |
| 549 addc r11,r7,r11 | |
| 550 adde r9,r8,r9 | |
| 551 addze r10,r10 | |
| 552 #sqr_add_c2(a,3,2,c3,c1,c2); | |
| 553 $LD r5,`2*$BNSZ`(r4) | |
| 554 $LD r6,`3*$BNSZ`(r4) | |
| 555 $UMULL r7,r5,r6 | |
| 556 $UMULH r8,r5,r6 | |
| 557 | |
| 558 addc r11,r7,r11 | |
| 559 adde r9,r8,r9 | |
| 560 addze r10,r10 | |
| 561 | |
| 562 addc r11,r7,r11 | |
| 563 adde r9,r8,r9 | |
| 564 addze r10,r10 | |
| 565 $ST r11,`5*$BNSZ`(r3) #r[5]=c3; | |
| 566 #sqr_add_c(a,3,c1,c2,c3); | |
| 567 $UMULL r7,r6,r6 | |
| 568 $UMULH r8,r6,r6 | |
| 569 addc r9,r7,r9 | |
| 570 adde r10,r8,r10 | |
| 571 addze r11,r0 | |
| 572 #sqr_add_c2(a,4,2,c1,c2,c3); | |
| 573 $LD r6,`4*$BNSZ`(r4) | |
| 574 $UMULL r7,r5,r6 | |
| 575 $UMULH r8,r5,r6 | |
| 576 | |
| 577 addc r9,r7,r9 | |
| 578 adde r10,r8,r10 | |
| 579 addze r11,r11 | |
| 580 | |
| 581 addc r9,r7,r9 | |
| 582 adde r10,r8,r10 | |
| 583 addze r11,r11 | |
| 584 #sqr_add_c2(a,5,1,c1,c2,c3); | |
| 585 $LD r5,`1*$BNSZ`(r4) | |
| 586 $LD r6,`5*$BNSZ`(r4) | |
| 587 $UMULL r7,r5,r6 | |
| 588 $UMULH r8,r5,r6 | |
| 589 | |
| 590 addc r9,r7,r9 | |
| 591 adde r10,r8,r10 | |
| 592 addze r11,r11 | |
| 593 | |
| 594 addc r9,r7,r9 | |
| 595 adde r10,r8,r10 | |
| 596 addze r11,r11 | |
| 597 #sqr_add_c2(a,6,0,c1,c2,c3); | |
| 598 $LD r5,`0*$BNSZ`(r4) | |
| 599 $LD r6,`6*$BNSZ`(r4) | |
| 600 $UMULL r7,r5,r6 | |
| 601 $UMULH r8,r5,r6 | |
| 602 addc r9,r7,r9 | |
| 603 adde r10,r8,r10 | |
| 604 addze r11,r11 | |
| 605 addc r9,r7,r9 | |
| 606 adde r10,r8,r10 | |
| 607 addze r11,r11 | |
| 608 $ST r9,`6*$BNSZ`(r3) #r[6]=c1; | |
| 609 #sqr_add_c2(a,7,0,c2,c3,c1); | |
| 610 $LD r6,`7*$BNSZ`(r4) | |
| 611 $UMULL r7,r5,r6 | |
| 612 $UMULH r8,r5,r6 | |
| 613 | |
| 614 addc r10,r7,r10 | |
| 615 adde r11,r8,r11 | |
| 616 addze r9,r0 | |
| 617 addc r10,r7,r10 | |
| 618 adde r11,r8,r11 | |
| 619 addze r9,r9 | |
| 620 #sqr_add_c2(a,6,1,c2,c3,c1); | |
| 621 $LD r5,`1*$BNSZ`(r4) | |
| 622 $LD r6,`6*$BNSZ`(r4) | |
| 623 $UMULL r7,r5,r6 | |
| 624 $UMULH r8,r5,r6 | |
| 625 | |
| 626 addc r10,r7,r10 | |
| 627 adde r11,r8,r11 | |
| 628 addze r9,r9 | |
| 629 addc r10,r7,r10 | |
| 630 adde r11,r8,r11 | |
| 631 addze r9,r9 | |
| 632 #sqr_add_c2(a,5,2,c2,c3,c1); | |
| 633 $LD r5,`2*$BNSZ`(r4) | |
| 634 $LD r6,`5*$BNSZ`(r4) | |
| 635 $UMULL r7,r5,r6 | |
| 636 $UMULH r8,r5,r6 | |
| 637 addc r10,r7,r10 | |
| 638 adde r11,r8,r11 | |
| 639 addze r9,r9 | |
| 640 addc r10,r7,r10 | |
| 641 adde r11,r8,r11 | |
| 642 addze r9,r9 | |
| 643 #sqr_add_c2(a,4,3,c2,c3,c1); | |
| 644 $LD r5,`3*$BNSZ`(r4) | |
| 645 $LD r6,`4*$BNSZ`(r4) | |
| 646 $UMULL r7,r5,r6 | |
| 647 $UMULH r8,r5,r6 | |
| 648 | |
| 649 addc r10,r7,r10 | |
| 650 adde r11,r8,r11 | |
| 651 addze r9,r9 | |
| 652 addc r10,r7,r10 | |
| 653 adde r11,r8,r11 | |
| 654 addze r9,r9 | |
| 655 $ST r10,`7*$BNSZ`(r3) #r[7]=c2; | |
| 656 #sqr_add_c(a,4,c3,c1,c2); | |
| 657 $UMULL r7,r6,r6 | |
| 658 $UMULH r8,r6,r6 | |
| 659 addc r11,r7,r11 | |
| 660 adde r9,r8,r9 | |
| 661 addze r10,r0 | |
| 662 #sqr_add_c2(a,5,3,c3,c1,c2); | |
| 663 $LD r6,`5*$BNSZ`(r4) | |
| 664 $UMULL r7,r5,r6 | |
| 665 $UMULH r8,r5,r6 | |
| 666 addc r11,r7,r11 | |
| 667 adde r9,r8,r9 | |
| 668 addze r10,r10 | |
| 669 addc r11,r7,r11 | |
| 670 adde r9,r8,r9 | |
| 671 addze r10,r10 | |
| 672 #sqr_add_c2(a,6,2,c3,c1,c2); | |
| 673 $LD r5,`2*$BNSZ`(r4) | |
| 674 $LD r6,`6*$BNSZ`(r4) | |
| 675 $UMULL r7,r5,r6 | |
| 676 $UMULH r8,r5,r6 | |
| 677 addc r11,r7,r11 | |
| 678 adde r9,r8,r9 | |
| 679 addze r10,r10 | |
| 680 | |
| 681 addc r11,r7,r11 | |
| 682 adde r9,r8,r9 | |
| 683 addze r10,r10 | |
| 684 #sqr_add_c2(a,7,1,c3,c1,c2); | |
| 685 $LD r5,`1*$BNSZ`(r4) | |
| 686 $LD r6,`7*$BNSZ`(r4) | |
| 687 $UMULL r7,r5,r6 | |
| 688 $UMULH r8,r5,r6 | |
| 689 addc r11,r7,r11 | |
| 690 adde r9,r8,r9 | |
| 691 addze r10,r10 | |
| 692 addc r11,r7,r11 | |
| 693 adde r9,r8,r9 | |
| 694 addze r10,r10 | |
| 695 $ST r11,`8*$BNSZ`(r3) #r[8]=c3; | |
| 696 #sqr_add_c2(a,7,2,c1,c2,c3); | |
| 697 $LD r5,`2*$BNSZ`(r4) | |
| 698 $UMULL r7,r5,r6 | |
| 699 $UMULH r8,r5,r6 | |
| 700 | |
| 701 addc r9,r7,r9 | |
| 702 adde r10,r8,r10 | |
| 703 addze r11,r0 | |
| 704 addc r9,r7,r9 | |
| 705 adde r10,r8,r10 | |
| 706 addze r11,r11 | |
| 707 #sqr_add_c2(a,6,3,c1,c2,c3); | |
| 708 $LD r5,`3*$BNSZ`(r4) | |
| 709 $LD r6,`6*$BNSZ`(r4) | |
| 710 $UMULL r7,r5,r6 | |
| 711 $UMULH r8,r5,r6 | |
| 712 addc r9,r7,r9 | |
| 713 adde r10,r8,r10 | |
| 714 addze r11,r11 | |
| 715 addc r9,r7,r9 | |
| 716 adde r10,r8,r10 | |
| 717 addze r11,r11 | |
| 718 #sqr_add_c2(a,5,4,c1,c2,c3); | |
| 719 $LD r5,`4*$BNSZ`(r4) | |
| 720 $LD r6,`5*$BNSZ`(r4) | |
| 721 $UMULL r7,r5,r6 | |
| 722 $UMULH r8,r5,r6 | |
| 723 addc r9,r7,r9 | |
| 724 adde r10,r8,r10 | |
| 725 addze r11,r11 | |
| 726 addc r9,r7,r9 | |
| 727 adde r10,r8,r10 | |
| 728 addze r11,r11 | |
| 729 $ST r9,`9*$BNSZ`(r3) #r[9]=c1; | |
| 730 #sqr_add_c(a,5,c2,c3,c1); | |
| 731 $UMULL r7,r6,r6 | |
| 732 $UMULH r8,r6,r6 | |
| 733 addc r10,r7,r10 | |
| 734 adde r11,r8,r11 | |
| 735 addze r9,r0 | |
| 736 #sqr_add_c2(a,6,4,c2,c3,c1); | |
| 737 $LD r6,`6*$BNSZ`(r4) | |
| 738 $UMULL r7,r5,r6 | |
| 739 $UMULH r8,r5,r6 | |
| 740 addc r10,r7,r10 | |
| 741 adde r11,r8,r11 | |
| 742 addze r9,r9 | |
| 743 addc r10,r7,r10 | |
| 744 adde r11,r8,r11 | |
| 745 addze r9,r9 | |
| 746 #sqr_add_c2(a,7,3,c2,c3,c1); | |
| 747 $LD r5,`3*$BNSZ`(r4) | |
| 748 $LD r6,`7*$BNSZ`(r4) | |
| 749 $UMULL r7,r5,r6 | |
| 750 $UMULH r8,r5,r6 | |
| 751 addc r10,r7,r10 | |
| 752 adde r11,r8,r11 | |
| 753 addze r9,r9 | |
| 754 addc r10,r7,r10 | |
| 755 adde r11,r8,r11 | |
| 756 addze r9,r9 | |
| 757 $ST r10,`10*$BNSZ`(r3) #r[10]=c2; | |
| 758 #sqr_add_c2(a,7,4,c3,c1,c2); | |
| 759 $LD r5,`4*$BNSZ`(r4) | |
| 760 $UMULL r7,r5,r6 | |
| 761 $UMULH r8,r5,r6 | |
| 762 addc r11,r7,r11 | |
| 763 adde r9,r8,r9 | |
| 764 addze r10,r0 | |
| 765 addc r11,r7,r11 | |
| 766 adde r9,r8,r9 | |
| 767 addze r10,r10 | |
| 768 #sqr_add_c2(a,6,5,c3,c1,c2); | |
| 769 $LD r5,`5*$BNSZ`(r4) | |
| 770 $LD r6,`6*$BNSZ`(r4) | |
| 771 $UMULL r7,r5,r6 | |
| 772 $UMULH r8,r5,r6 | |
| 773 addc r11,r7,r11 | |
| 774 adde r9,r8,r9 | |
| 775 addze r10,r10 | |
| 776 addc r11,r7,r11 | |
| 777 adde r9,r8,r9 | |
| 778 addze r10,r10 | |
| 779 $ST r11,`11*$BNSZ`(r3) #r[11]=c3; | |
| 780 #sqr_add_c(a,6,c1,c2,c3); | |
| 781 $UMULL r7,r6,r6 | |
| 782 $UMULH r8,r6,r6 | |
| 783 addc r9,r7,r9 | |
| 784 adde r10,r8,r10 | |
| 785 addze r11,r0 | |
| 786 #sqr_add_c2(a,7,5,c1,c2,c3) | |
| 787 $LD r6,`7*$BNSZ`(r4) | |
| 788 $UMULL r7,r5,r6 | |
| 789 $UMULH r8,r5,r6 | |
| 790 addc r9,r7,r9 | |
| 791 adde r10,r8,r10 | |
| 792 addze r11,r11 | |
| 793 addc r9,r7,r9 | |
| 794 adde r10,r8,r10 | |
| 795 addze r11,r11 | |
| 796 $ST r9,`12*$BNSZ`(r3) #r[12]=c1; | |
| 797 | |
| 798 #sqr_add_c2(a,7,6,c2,c3,c1) | |
| 799 $LD r5,`6*$BNSZ`(r4) | |
| 800 $UMULL r7,r5,r6 | |
| 801 $UMULH r8,r5,r6 | |
| 802 addc r10,r7,r10 | |
| 803 adde r11,r8,r11 | |
| 804 addze r9,r0 | |
| 805 addc r10,r7,r10 | |
| 806 adde r11,r8,r11 | |
| 807 addze r9,r9 | |
| 808 $ST r10,`13*$BNSZ`(r3) #r[13]=c2; | |
| 809 #sqr_add_c(a,7,c3,c1,c2); | |
| 810 $UMULL r7,r6,r6 | |
| 811 $UMULH r8,r6,r6 | |
| 812 addc r11,r7,r11 | |
| 813 adde r9,r8,r9 | |
| 814 $ST r11,`14*$BNSZ`(r3) #r[14]=c3; | |
| 815 $ST r9, `15*$BNSZ`(r3) #r[15]=c1; | |
| 816 | |
| 817 | |
| 818 blr | |
| 819 .long 0 | |
| 820 .byte 0,12,0x14,0,0,0,2,0 | |
| 821 .long 0 | |
| 822 | |
| 823 # | |
| 824 # NOTE: The following label name should be changed to | |
| 825 # "bn_mul_comba4" i.e. remove the first dot | |
| 826 # for the gcc compiler. This should be automatically | |
| 827 # done in the build | |
| 828 # | |
| 829 | |
| 830 .align 4 | |
| 831 .bn_mul_comba4: | |
| 832 # | |
| 833 # This is an optimized version of the bn_mul_comba4 routine. | |
| 834 # | |
| 835 # void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b) | |
| 836 # r3 contains r | |
| 837 # r4 contains a | |
| 838 # r5 contains b | |
| 839 # r6, r7 are the 2 BN_ULONGs being multiplied. | |
| 840 # r8, r9 are the results of the 32x32 giving 64 multiply. | |
| 841 # r10, r11, r12 are the equivalents of c1, c2, and c3. | |
| 842 # | |
| 843 xor r0,r0,r0 #r0=0. Used in addze below. | |
| 844 #mul_add_c(a[0],b[0],c1,c2,c3); | |
| 845 $LD r6,`0*$BNSZ`(r4) | |
| 846 $LD r7,`0*$BNSZ`(r5) | |
| 847 $UMULL r10,r6,r7 | |
| 848 $UMULH r11,r6,r7 | |
| 849 $ST r10,`0*$BNSZ`(r3) #r[0]=c1 | |
| 850 #mul_add_c(a[0],b[1],c2,c3,c1); | |
| 851 $LD r7,`1*$BNSZ`(r5) | |
| 852 $UMULL r8,r6,r7 | |
| 853 $UMULH r9,r6,r7 | |
| 854 addc r11,r8,r11 | |
| 855 adde r12,r9,r0 | |
| 856 addze r10,r0 | |
| 857 #mul_add_c(a[1],b[0],c2,c3,c1); | |
| 858 $LD r6, `1*$BNSZ`(r4) | |
| 859 $LD r7, `0*$BNSZ`(r5) | |
| 860 $UMULL r8,r6,r7 | |
| 861 $UMULH r9,r6,r7 | |
| 862 addc r11,r8,r11 | |
| 863 adde r12,r9,r12 | |
| 864 addze r10,r10 | |
| 865 $ST r11,`1*$BNSZ`(r3) #r[1]=c2 | |
| 866 #mul_add_c(a[2],b[0],c3,c1,c2); | |
| 867 $LD r6,`2*$BNSZ`(r4) | |
| 868 $UMULL r8,r6,r7 | |
| 869 $UMULH r9,r6,r7 | |
| 870 addc r12,r8,r12 | |
| 871 adde r10,r9,r10 | |
| 872 addze r11,r0 | |
| 873 #mul_add_c(a[1],b[1],c3,c1,c2); | |
| 874 $LD r6,`1*$BNSZ`(r4) | |
| 875 $LD r7,`1*$BNSZ`(r5) | |
| 876 $UMULL r8,r6,r7 | |
| 877 $UMULH r9,r6,r7 | |
| 878 addc r12,r8,r12 | |
| 879 adde r10,r9,r10 | |
| 880 addze r11,r11 | |
| 881 #mul_add_c(a[0],b[2],c3,c1,c2); | |
| 882 $LD r6,`0*$BNSZ`(r4) | |
| 883 $LD r7,`2*$BNSZ`(r5) | |
| 884 $UMULL r8,r6,r7 | |
| 885 $UMULH r9,r6,r7 | |
| 886 addc r12,r8,r12 | |
| 887 adde r10,r9,r10 | |
| 888 addze r11,r11 | |
| 889 $ST r12,`2*$BNSZ`(r3) #r[2]=c3 | |
| 890 #mul_add_c(a[0],b[3],c1,c2,c3); | |
| 891 $LD r7,`3*$BNSZ`(r5) | |
| 892 $UMULL r8,r6,r7 | |
| 893 $UMULH r9,r6,r7 | |
| 894 addc r10,r8,r10 | |
| 895 adde r11,r9,r11 | |
| 896 addze r12,r0 | |
| 897 #mul_add_c(a[1],b[2],c1,c2,c3); | |
| 898 $LD r6,`1*$BNSZ`(r4) | |
| 899 $LD r7,`2*$BNSZ`(r5) | |
| 900 $UMULL r8,r6,r7 | |
| 901 $UMULH r9,r6,r7 | |
| 902 addc r10,r8,r10 | |
| 903 adde r11,r9,r11 | |
| 904 addze r12,r12 | |
| 905 #mul_add_c(a[2],b[1],c1,c2,c3); | |
| 906 $LD r6,`2*$BNSZ`(r4) | |
| 907 $LD r7,`1*$BNSZ`(r5) | |
| 908 $UMULL r8,r6,r7 | |
| 909 $UMULH r9,r6,r7 | |
| 910 addc r10,r8,r10 | |
| 911 adde r11,r9,r11 | |
| 912 addze r12,r12 | |
| 913 #mul_add_c(a[3],b[0],c1,c2,c3); | |
| 914 $LD r6,`3*$BNSZ`(r4) | |
| 915 $LD r7,`0*$BNSZ`(r5) | |
| 916 $UMULL r8,r6,r7 | |
| 917 $UMULH r9,r6,r7 | |
| 918 addc r10,r8,r10 | |
| 919 adde r11,r9,r11 | |
| 920 addze r12,r12 | |
| 921 $ST r10,`3*$BNSZ`(r3) #r[3]=c1 | |
| 922 #mul_add_c(a[3],b[1],c2,c3,c1); | |
| 923 $LD r7,`1*$BNSZ`(r5) | |
| 924 $UMULL r8,r6,r7 | |
| 925 $UMULH r9,r6,r7 | |
| 926 addc r11,r8,r11 | |
| 927 adde r12,r9,r12 | |
| 928 addze r10,r0 | |
| 929 #mul_add_c(a[2],b[2],c2,c3,c1); | |
| 930 $LD r6,`2*$BNSZ`(r4) | |
| 931 $LD r7,`2*$BNSZ`(r5) | |
| 932 $UMULL r8,r6,r7 | |
| 933 $UMULH r9,r6,r7 | |
| 934 addc r11,r8,r11 | |
| 935 adde r12,r9,r12 | |
| 936 addze r10,r10 | |
| 937 #mul_add_c(a[1],b[3],c2,c3,c1); | |
| 938 $LD r6,`1*$BNSZ`(r4) | |
| 939 $LD r7,`3*$BNSZ`(r5) | |
| 940 $UMULL r8,r6,r7 | |
| 941 $UMULH r9,r6,r7 | |
| 942 addc r11,r8,r11 | |
| 943 adde r12,r9,r12 | |
| 944 addze r10,r10 | |
| 945 $ST r11,`4*$BNSZ`(r3) #r[4]=c2 | |
| 946 #mul_add_c(a[2],b[3],c3,c1,c2); | |
| 947 $LD r6,`2*$BNSZ`(r4) | |
| 948 $UMULL r8,r6,r7 | |
| 949 $UMULH r9,r6,r7 | |
| 950 addc r12,r8,r12 | |
| 951 adde r10,r9,r10 | |
| 952 addze r11,r0 | |
| 953 #mul_add_c(a[3],b[2],c3,c1,c2); | |
| 954 $LD r6,`3*$BNSZ`(r4) | |
| 955 $LD r7,`2*$BNSZ`(r5) | |
| 956 $UMULL r8,r6,r7 | |
| 957 $UMULH r9,r6,r7 | |
| 958 addc r12,r8,r12 | |
| 959 adde r10,r9,r10 | |
| 960 addze r11,r11 | |
| 961 $ST r12,`5*$BNSZ`(r3) #r[5]=c3 | |
| 962 #mul_add_c(a[3],b[3],c1,c2,c3); | |
| 963 $LD r7,`3*$BNSZ`(r5) | |
| 964 $UMULL r8,r6,r7 | |
| 965 $UMULH r9,r6,r7 | |
| 966 addc r10,r8,r10 | |
| 967 adde r11,r9,r11 | |
| 968 | |
| 969 $ST r10,`6*$BNSZ`(r3) #r[6]=c1 | |
| 970 $ST r11,`7*$BNSZ`(r3) #r[7]=c2 | |
| 971 blr | |
| 972 .long 0 | |
| 973 .byte 0,12,0x14,0,0,0,3,0 | |
| 974 .long 0 | |
| 975 | |
| 976 # | |
| 977 # NOTE: The following label name should be changed to | |
| 978 # "bn_mul_comba8" i.e. remove the first dot | |
| 979 # for the gcc compiler. This should be automatically | |
| 980 # done in the build | |
| 981 # | |
| 982 | |
| 983 .align 4 | |
| 984 .bn_mul_comba8: | |
| 985 # | |
| 986 # Optimized version of the bn_mul_comba8 routine. | |
| 987 # | |
| 988 # void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b) | |
| 989 # r3 contains r | |
| 990 # r4 contains a | |
| 991 # r5 contains b | |
| 992 # r6, r7 are the 2 BN_ULONGs being multiplied. | |
| 993 # r8, r9 are the results of the 32x32 giving 64 multiply. | |
| 994 # r10, r11, r12 are the equivalents of c1, c2, and c3. | |
| 995 # | |
| 996 xor r0,r0,r0 #r0=0. Used in addze below. | |
| 997 | |
| 998 #mul_add_c(a[0],b[0],c1,c2,c3); | |
| 999 $LD r6,`0*$BNSZ`(r4) #a[0] | |
| 1000 $LD r7,`0*$BNSZ`(r5) #b[0] | |
| 1001 $UMULL r10,r6,r7 | |
| 1002 $UMULH r11,r6,r7 | |
| 1003 $ST r10,`0*$BNSZ`(r3) #r[0]=c1; | |
| 1004 #mul_add_c(a[0],b[1],c2,c3,c1); | |
| 1005 $LD r7,`1*$BNSZ`(r5) | |
| 1006 $UMULL r8,r6,r7 | |
| 1007 $UMULH r9,r6,r7 | |
| 1008 addc r11,r11,r8 | |
| 1009 addze r12,r9 # since we didnt set r12 to zero before. | |
| 1010 addze r10,r0 | |
| 1011 #mul_add_c(a[1],b[0],c2,c3,c1); | |
| 1012 $LD r6,`1*$BNSZ`(r4) | |
| 1013 $LD r7,`0*$BNSZ`(r5) | |
| 1014 $UMULL r8,r6,r7 | |
| 1015 $UMULH r9,r6,r7 | |
| 1016 addc r11,r11,r8 | |
| 1017 adde r12,r12,r9 | |
| 1018 addze r10,r10 | |
| 1019 $ST r11,`1*$BNSZ`(r3) #r[1]=c2; | |
| 1020 #mul_add_c(a[2],b[0],c3,c1,c2); | |
| 1021 $LD r6,`2*$BNSZ`(r4) | |
| 1022 $UMULL r8,r6,r7 | |
| 1023 $UMULH r9,r6,r7 | |
| 1024 addc r12,r12,r8 | |
| 1025 adde r10,r10,r9 | |
| 1026 addze r11,r0 | |
| 1027 #mul_add_c(a[1],b[1],c3,c1,c2); | |
| 1028 $LD r6,`1*$BNSZ`(r4) | |
| 1029 $LD r7,`1*$BNSZ`(r5) | |
| 1030 $UMULL r8,r6,r7 | |
| 1031 $UMULH r9,r6,r7 | |
| 1032 addc r12,r12,r8 | |
| 1033 adde r10,r10,r9 | |
| 1034 addze r11,r11 | |
| 1035 #mul_add_c(a[0],b[2],c3,c1,c2); | |
| 1036 $LD r6,`0*$BNSZ`(r4) | |
| 1037 $LD r7,`2*$BNSZ`(r5) | |
| 1038 $UMULL r8,r6,r7 | |
| 1039 $UMULH r9,r6,r7 | |
| 1040 addc r12,r12,r8 | |
| 1041 adde r10,r10,r9 | |
| 1042 addze r11,r11 | |
| 1043 $ST r12,`2*$BNSZ`(r3) #r[2]=c3; | |
| 1044 #mul_add_c(a[0],b[3],c1,c2,c3); | |
| 1045 $LD r7,`3*$BNSZ`(r5) | |
| 1046 $UMULL r8,r6,r7 | |
| 1047 $UMULH r9,r6,r7 | |
| 1048 addc r10,r10,r8 | |
| 1049 adde r11,r11,r9 | |
| 1050 addze r12,r0 | |
| 1051 #mul_add_c(a[1],b[2],c1,c2,c3); | |
| 1052 $LD r6,`1*$BNSZ`(r4) | |
| 1053 $LD r7,`2*$BNSZ`(r5) | |
| 1054 $UMULL r8,r6,r7 | |
| 1055 $UMULH r9,r6,r7 | |
| 1056 addc r10,r10,r8 | |
| 1057 adde r11,r11,r9 | |
| 1058 addze r12,r12 | |
| 1059 | |
| 1060 #mul_add_c(a[2],b[1],c1,c2,c3); | |
| 1061 $LD r6,`2*$BNSZ`(r4) | |
| 1062 $LD r7,`1*$BNSZ`(r5) | |
| 1063 $UMULL r8,r6,r7 | |
| 1064 $UMULH r9,r6,r7 | |
| 1065 addc r10,r10,r8 | |
| 1066 adde r11,r11,r9 | |
| 1067 addze r12,r12 | |
| 1068 #mul_add_c(a[3],b[0],c1,c2,c3); | |
| 1069 $LD r6,`3*$BNSZ`(r4) | |
| 1070 $LD r7,`0*$BNSZ`(r5) | |
| 1071 $UMULL r8,r6,r7 | |
| 1072 $UMULH r9,r6,r7 | |
| 1073 addc r10,r10,r8 | |
| 1074 adde r11,r11,r9 | |
| 1075 addze r12,r12 | |
| 1076 $ST r10,`3*$BNSZ`(r3) #r[3]=c1; | |
| 1077 #mul_add_c(a[4],b[0],c2,c3,c1); | |
| 1078 $LD r6,`4*$BNSZ`(r4) | |
| 1079 $UMULL r8,r6,r7 | |
| 1080 $UMULH r9,r6,r7 | |
| 1081 addc r11,r11,r8 | |
| 1082 adde r12,r12,r9 | |
| 1083 addze r10,r0 | |
| 1084 #mul_add_c(a[3],b[1],c2,c3,c1); | |
| 1085 $LD r6,`3*$BNSZ`(r4) | |
| 1086 $LD r7,`1*$BNSZ`(r5) | |
| 1087 $UMULL r8,r6,r7 | |
| 1088 $UMULH r9,r6,r7 | |
| 1089 addc r11,r11,r8 | |
| 1090 adde r12,r12,r9 | |
| 1091 addze r10,r10 | |
| 1092 #mul_add_c(a[2],b[2],c2,c3,c1); | |
| 1093 $LD r6,`2*$BNSZ`(r4) | |
| 1094 $LD r7,`2*$BNSZ`(r5) | |
| 1095 $UMULL r8,r6,r7 | |
| 1096 $UMULH r9,r6,r7 | |
| 1097 addc r11,r11,r8 | |
| 1098 adde r12,r12,r9 | |
| 1099 addze r10,r10 | |
| 1100 #mul_add_c(a[1],b[3],c2,c3,c1); | |
| 1101 $LD r6,`1*$BNSZ`(r4) | |
| 1102 $LD r7,`3*$BNSZ`(r5) | |
| 1103 $UMULL r8,r6,r7 | |
| 1104 $UMULH r9,r6,r7 | |
| 1105 addc r11,r11,r8 | |
| 1106 adde r12,r12,r9 | |
| 1107 addze r10,r10 | |
| 1108 #mul_add_c(a[0],b[4],c2,c3,c1); | |
| 1109 $LD r6,`0*$BNSZ`(r4) | |
| 1110 $LD r7,`4*$BNSZ`(r5) | |
| 1111 $UMULL r8,r6,r7 | |
| 1112 $UMULH r9,r6,r7 | |
| 1113 addc r11,r11,r8 | |
| 1114 adde r12,r12,r9 | |
| 1115 addze r10,r10 | |
| 1116 $ST r11,`4*$BNSZ`(r3) #r[4]=c2; | |
| 1117 #mul_add_c(a[0],b[5],c3,c1,c2); | |
| 1118 $LD r7,`5*$BNSZ`(r5) | |
| 1119 $UMULL r8,r6,r7 | |
| 1120 $UMULH r9,r6,r7 | |
| 1121 addc r12,r12,r8 | |
| 1122 adde r10,r10,r9 | |
| 1123 addze r11,r0 | |
| 1124 #mul_add_c(a[1],b[4],c3,c1,c2); | |
| 1125 $LD r6,`1*$BNSZ`(r4) | |
| 1126 $LD r7,`4*$BNSZ`(r5) | |
| 1127 $UMULL r8,r6,r7 | |
| 1128 $UMULH r9,r6,r7 | |
| 1129 addc r12,r12,r8 | |
| 1130 adde r10,r10,r9 | |
| 1131 addze r11,r11 | |
| 1132 #mul_add_c(a[2],b[3],c3,c1,c2); | |
| 1133 $LD r6,`2*$BNSZ`(r4) | |
| 1134 $LD r7,`3*$BNSZ`(r5) | |
| 1135 $UMULL r8,r6,r7 | |
| 1136 $UMULH r9,r6,r7 | |
| 1137 addc r12,r12,r8 | |
| 1138 adde r10,r10,r9 | |
| 1139 addze r11,r11 | |
| 1140 #mul_add_c(a[3],b[2],c3,c1,c2); | |
| 1141 $LD r6,`3*$BNSZ`(r4) | |
| 1142 $LD r7,`2*$BNSZ`(r5) | |
| 1143 $UMULL r8,r6,r7 | |
| 1144 $UMULH r9,r6,r7 | |
| 1145 addc r12,r12,r8 | |
| 1146 adde r10,r10,r9 | |
| 1147 addze r11,r11 | |
| 1148 #mul_add_c(a[4],b[1],c3,c1,c2); | |
| 1149 $LD r6,`4*$BNSZ`(r4) | |
| 1150 $LD r7,`1*$BNSZ`(r5) | |
| 1151 $UMULL r8,r6,r7 | |
| 1152 $UMULH r9,r6,r7 | |
| 1153 addc r12,r12,r8 | |
| 1154 adde r10,r10,r9 | |
| 1155 addze r11,r11 | |
| 1156 #mul_add_c(a[5],b[0],c3,c1,c2); | |
| 1157 $LD r6,`5*$BNSZ`(r4) | |
| 1158 $LD r7,`0*$BNSZ`(r5) | |
| 1159 $UMULL r8,r6,r7 | |
| 1160 $UMULH r9,r6,r7 | |
| 1161 addc r12,r12,r8 | |
| 1162 adde r10,r10,r9 | |
| 1163 addze r11,r11 | |
| 1164 $ST r12,`5*$BNSZ`(r3) #r[5]=c3; | |
| 1165 #mul_add_c(a[6],b[0],c1,c2,c3); | |
| 1166 $LD r6,`6*$BNSZ`(r4) | |
| 1167 $UMULL r8,r6,r7 | |
| 1168 $UMULH r9,r6,r7 | |
| 1169 addc r10,r10,r8 | |
| 1170 adde r11,r11,r9 | |
| 1171 addze r12,r0 | |
| 1172 #mul_add_c(a[5],b[1],c1,c2,c3); | |
| 1173 $LD r6,`5*$BNSZ`(r4) | |
| 1174 $LD r7,`1*$BNSZ`(r5) | |
| 1175 $UMULL r8,r6,r7 | |
| 1176 $UMULH r9,r6,r7 | |
| 1177 addc r10,r10,r8 | |
| 1178 adde r11,r11,r9 | |
| 1179 addze r12,r12 | |
| 1180 #mul_add_c(a[4],b[2],c1,c2,c3); | |
| 1181 $LD r6,`4*$BNSZ`(r4) | |
| 1182 $LD r7,`2*$BNSZ`(r5) | |
| 1183 $UMULL r8,r6,r7 | |
| 1184 $UMULH r9,r6,r7 | |
| 1185 addc r10,r10,r8 | |
| 1186 adde r11,r11,r9 | |
| 1187 addze r12,r12 | |
| 1188 #mul_add_c(a[3],b[3],c1,c2,c3); | |
| 1189 $LD r6,`3*$BNSZ`(r4) | |
| 1190 $LD r7,`3*$BNSZ`(r5) | |
| 1191 $UMULL r8,r6,r7 | |
| 1192 $UMULH r9,r6,r7 | |
| 1193 addc r10,r10,r8 | |
| 1194 adde r11,r11,r9 | |
| 1195 addze r12,r12 | |
| 1196 #mul_add_c(a[2],b[4],c1,c2,c3); | |
| 1197 $LD r6,`2*$BNSZ`(r4) | |
| 1198 $LD r7,`4*$BNSZ`(r5) | |
| 1199 $UMULL r8,r6,r7 | |
| 1200 $UMULH r9,r6,r7 | |
| 1201 addc r10,r10,r8 | |
| 1202 adde r11,r11,r9 | |
| 1203 addze r12,r12 | |
| 1204 #mul_add_c(a[1],b[5],c1,c2,c3); | |
| 1205 $LD r6,`1*$BNSZ`(r4) | |
| 1206 $LD r7,`5*$BNSZ`(r5) | |
| 1207 $UMULL r8,r6,r7 | |
| 1208 $UMULH r9,r6,r7 | |
| 1209 addc r10,r10,r8 | |
| 1210 adde r11,r11,r9 | |
| 1211 addze r12,r12 | |
| 1212 #mul_add_c(a[0],b[6],c1,c2,c3); | |
| 1213 $LD r6,`0*$BNSZ`(r4) | |
| 1214 $LD r7,`6*$BNSZ`(r5) | |
| 1215 $UMULL r8,r6,r7 | |
| 1216 $UMULH r9,r6,r7 | |
| 1217 addc r10,r10,r8 | |
| 1218 adde r11,r11,r9 | |
| 1219 addze r12,r12 | |
| 1220 $ST r10,`6*$BNSZ`(r3) #r[6]=c1; | |
| 1221 #mul_add_c(a[0],b[7],c2,c3,c1); | |
| 1222 $LD r7,`7*$BNSZ`(r5) | |
| 1223 $UMULL r8,r6,r7 | |
| 1224 $UMULH r9,r6,r7 | |
| 1225 addc r11,r11,r8 | |
| 1226 adde r12,r12,r9 | |
| 1227 addze r10,r0 | |
| 1228 #mul_add_c(a[1],b[6],c2,c3,c1); | |
| 1229 $LD r6,`1*$BNSZ`(r4) | |
| 1230 $LD r7,`6*$BNSZ`(r5) | |
| 1231 $UMULL r8,r6,r7 | |
| 1232 $UMULH r9,r6,r7 | |
| 1233 addc r11,r11,r8 | |
| 1234 adde r12,r12,r9 | |
| 1235 addze r10,r10 | |
| 1236 #mul_add_c(a[2],b[5],c2,c3,c1); | |
| 1237 $LD r6,`2*$BNSZ`(r4) | |
| 1238 $LD r7,`5*$BNSZ`(r5) | |
| 1239 $UMULL r8,r6,r7 | |
| 1240 $UMULH r9,r6,r7 | |
| 1241 addc r11,r11,r8 | |
| 1242 adde r12,r12,r9 | |
| 1243 addze r10,r10 | |
| 1244 #mul_add_c(a[3],b[4],c2,c3,c1); | |
| 1245 $LD r6,`3*$BNSZ`(r4) | |
| 1246 $LD r7,`4*$BNSZ`(r5) | |
| 1247 $UMULL r8,r6,r7 | |
| 1248 $UMULH r9,r6,r7 | |
| 1249 addc r11,r11,r8 | |
| 1250 adde r12,r12,r9 | |
| 1251 addze r10,r10 | |
| 1252 #mul_add_c(a[4],b[3],c2,c3,c1); | |
| 1253 $LD r6,`4*$BNSZ`(r4) | |
| 1254 $LD r7,`3*$BNSZ`(r5) | |
| 1255 $UMULL r8,r6,r7 | |
| 1256 $UMULH r9,r6,r7 | |
| 1257 addc r11,r11,r8 | |
| 1258 adde r12,r12,r9 | |
| 1259 addze r10,r10 | |
| 1260 #mul_add_c(a[5],b[2],c2,c3,c1); | |
| 1261 $LD r6,`5*$BNSZ`(r4) | |
| 1262 $LD r7,`2*$BNSZ`(r5) | |
| 1263 $UMULL r8,r6,r7 | |
| 1264 $UMULH r9,r6,r7 | |
| 1265 addc r11,r11,r8 | |
| 1266 adde r12,r12,r9 | |
| 1267 addze r10,r10 | |
| 1268 #mul_add_c(a[6],b[1],c2,c3,c1); | |
| 1269 $LD r6,`6*$BNSZ`(r4) | |
| 1270 $LD r7,`1*$BNSZ`(r5) | |
| 1271 $UMULL r8,r6,r7 | |
| 1272 $UMULH r9,r6,r7 | |
| 1273 addc r11,r11,r8 | |
| 1274 adde r12,r12,r9 | |
| 1275 addze r10,r10 | |
| 1276 #mul_add_c(a[7],b[0],c2,c3,c1); | |
| 1277 $LD r6,`7*$BNSZ`(r4) | |
| 1278 $LD r7,`0*$BNSZ`(r5) | |
| 1279 $UMULL r8,r6,r7 | |
| 1280 $UMULH r9,r6,r7 | |
| 1281 addc r11,r11,r8 | |
| 1282 adde r12,r12,r9 | |
| 1283 addze r10,r10 | |
| 1284 $ST r11,`7*$BNSZ`(r3) #r[7]=c2; | |
| 1285 #mul_add_c(a[7],b[1],c3,c1,c2); | |
| 1286 $LD r7,`1*$BNSZ`(r5) | |
| 1287 $UMULL r8,r6,r7 | |
| 1288 $UMULH r9,r6,r7 | |
| 1289 addc r12,r12,r8 | |
| 1290 adde r10,r10,r9 | |
| 1291 addze r11,r0 | |
| 1292 #mul_add_c(a[6],b[2],c3,c1,c2); | |
| 1293 $LD r6,`6*$BNSZ`(r4) | |
| 1294 $LD r7,`2*$BNSZ`(r5) | |
| 1295 $UMULL r8,r6,r7 | |
| 1296 $UMULH r9,r6,r7 | |
| 1297 addc r12,r12,r8 | |
| 1298 adde r10,r10,r9 | |
| 1299 addze r11,r11 | |
| 1300 #mul_add_c(a[5],b[3],c3,c1,c2); | |
| 1301 $LD r6,`5*$BNSZ`(r4) | |
| 1302 $LD r7,`3*$BNSZ`(r5) | |
| 1303 $UMULL r8,r6,r7 | |
| 1304 $UMULH r9,r6,r7 | |
| 1305 addc r12,r12,r8 | |
| 1306 adde r10,r10,r9 | |
| 1307 addze r11,r11 | |
| 1308 #mul_add_c(a[4],b[4],c3,c1,c2); | |
| 1309 $LD r6,`4*$BNSZ`(r4) | |
| 1310 $LD r7,`4*$BNSZ`(r5) | |
| 1311 $UMULL r8,r6,r7 | |
| 1312 $UMULH r9,r6,r7 | |
| 1313 addc r12,r12,r8 | |
| 1314 adde r10,r10,r9 | |
| 1315 addze r11,r11 | |
| 1316 #mul_add_c(a[3],b[5],c3,c1,c2); | |
| 1317 $LD r6,`3*$BNSZ`(r4) | |
| 1318 $LD r7,`5*$BNSZ`(r5) | |
| 1319 $UMULL r8,r6,r7 | |
| 1320 $UMULH r9,r6,r7 | |
| 1321 addc r12,r12,r8 | |
| 1322 adde r10,r10,r9 | |
| 1323 addze r11,r11 | |
| 1324 #mul_add_c(a[2],b[6],c3,c1,c2); | |
| 1325 $LD r6,`2*$BNSZ`(r4) | |
| 1326 $LD r7,`6*$BNSZ`(r5) | |
| 1327 $UMULL r8,r6,r7 | |
| 1328 $UMULH r9,r6,r7 | |
| 1329 addc r12,r12,r8 | |
| 1330 adde r10,r10,r9 | |
| 1331 addze r11,r11 | |
| 1332 #mul_add_c(a[1],b[7],c3,c1,c2); | |
| 1333 $LD r6,`1*$BNSZ`(r4) | |
| 1334 $LD r7,`7*$BNSZ`(r5) | |
| 1335 $UMULL r8,r6,r7 | |
| 1336 $UMULH r9,r6,r7 | |
| 1337 addc r12,r12,r8 | |
| 1338 adde r10,r10,r9 | |
| 1339 addze r11,r11 | |
| 1340 $ST r12,`8*$BNSZ`(r3) #r[8]=c3; | |
| 1341 #mul_add_c(a[2],b[7],c1,c2,c3); | |
| 1342 $LD r6,`2*$BNSZ`(r4) | |
| 1343 $UMULL r8,r6,r7 | |
| 1344 $UMULH r9,r6,r7 | |
| 1345 addc r10,r10,r8 | |
| 1346 adde r11,r11,r9 | |
| 1347 addze r12,r0 | |
| 1348 #mul_add_c(a[3],b[6],c1,c2,c3); | |
| 1349 $LD r6,`3*$BNSZ`(r4) | |
| 1350 $LD r7,`6*$BNSZ`(r5) | |
| 1351 $UMULL r8,r6,r7 | |
| 1352 $UMULH r9,r6,r7 | |
| 1353 addc r10,r10,r8 | |
| 1354 adde r11,r11,r9 | |
| 1355 addze r12,r12 | |
| 1356 #mul_add_c(a[4],b[5],c1,c2,c3); | |
| 1357 $LD r6,`4*$BNSZ`(r4) | |
| 1358 $LD r7,`5*$BNSZ`(r5) | |
| 1359 $UMULL r8,r6,r7 | |
| 1360 $UMULH r9,r6,r7 | |
| 1361 addc r10,r10,r8 | |
| 1362 adde r11,r11,r9 | |
| 1363 addze r12,r12 | |
| 1364 #mul_add_c(a[5],b[4],c1,c2,c3); | |
| 1365 $LD r6,`5*$BNSZ`(r4) | |
| 1366 $LD r7,`4*$BNSZ`(r5) | |
| 1367 $UMULL r8,r6,r7 | |
| 1368 $UMULH r9,r6,r7 | |
| 1369 addc r10,r10,r8 | |
| 1370 adde r11,r11,r9 | |
| 1371 addze r12,r12 | |
| 1372 #mul_add_c(a[6],b[3],c1,c2,c3); | |
| 1373 $LD r6,`6*$BNSZ`(r4) | |
| 1374 $LD r7,`3*$BNSZ`(r5) | |
| 1375 $UMULL r8,r6,r7 | |
| 1376 $UMULH r9,r6,r7 | |
| 1377 addc r10,r10,r8 | |
| 1378 adde r11,r11,r9 | |
| 1379 addze r12,r12 | |
| 1380 #mul_add_c(a[7],b[2],c1,c2,c3); | |
| 1381 $LD r6,`7*$BNSZ`(r4) | |
| 1382 $LD r7,`2*$BNSZ`(r5) | |
| 1383 $UMULL r8,r6,r7 | |
| 1384 $UMULH r9,r6,r7 | |
| 1385 addc r10,r10,r8 | |
| 1386 adde r11,r11,r9 | |
| 1387 addze r12,r12 | |
| 1388 $ST r10,`9*$BNSZ`(r3) #r[9]=c1; | |
| 1389 #mul_add_c(a[7],b[3],c2,c3,c1); | |
| 1390 $LD r7,`3*$BNSZ`(r5) | |
| 1391 $UMULL r8,r6,r7 | |
| 1392 $UMULH r9,r6,r7 | |
| 1393 addc r11,r11,r8 | |
| 1394 adde r12,r12,r9 | |
| 1395 addze r10,r0 | |
| 1396 #mul_add_c(a[6],b[4],c2,c3,c1); | |
| 1397 $LD r6,`6*$BNSZ`(r4) | |
| 1398 $LD r7,`4*$BNSZ`(r5) | |
| 1399 $UMULL r8,r6,r7 | |
| 1400 $UMULH r9,r6,r7 | |
| 1401 addc r11,r11,r8 | |
| 1402 adde r12,r12,r9 | |
| 1403 addze r10,r10 | |
| 1404 #mul_add_c(a[5],b[5],c2,c3,c1); | |
| 1405 $LD r6,`5*$BNSZ`(r4) | |
| 1406 $LD r7,`5*$BNSZ`(r5) | |
| 1407 $UMULL r8,r6,r7 | |
| 1408 $UMULH r9,r6,r7 | |
| 1409 addc r11,r11,r8 | |
| 1410 adde r12,r12,r9 | |
| 1411 addze r10,r10 | |
| 1412 #mul_add_c(a[4],b[6],c2,c3,c1); | |
| 1413 $LD r6,`4*$BNSZ`(r4) | |
| 1414 $LD r7,`6*$BNSZ`(r5) | |
| 1415 $UMULL r8,r6,r7 | |
| 1416 $UMULH r9,r6,r7 | |
| 1417 addc r11,r11,r8 | |
| 1418 adde r12,r12,r9 | |
| 1419 addze r10,r10 | |
| 1420 #mul_add_c(a[3],b[7],c2,c3,c1); | |
| 1421 $LD r6,`3*$BNSZ`(r4) | |
| 1422 $LD r7,`7*$BNSZ`(r5) | |
| 1423 $UMULL r8,r6,r7 | |
| 1424 $UMULH r9,r6,r7 | |
| 1425 addc r11,r11,r8 | |
| 1426 adde r12,r12,r9 | |
| 1427 addze r10,r10 | |
| 1428 $ST r11,`10*$BNSZ`(r3) #r[10]=c2; | |
| 1429 #mul_add_c(a[4],b[7],c3,c1,c2); | |
| 1430 $LD r6,`4*$BNSZ`(r4) | |
| 1431 $UMULL r8,r6,r7 | |
| 1432 $UMULH r9,r6,r7 | |
| 1433 addc r12,r12,r8 | |
| 1434 adde r10,r10,r9 | |
| 1435 addze r11,r0 | |
| 1436 #mul_add_c(a[5],b[6],c3,c1,c2); | |
| 1437 $LD r6,`5*$BNSZ`(r4) | |
| 1438 $LD r7,`6*$BNSZ`(r5) | |
| 1439 $UMULL r8,r6,r7 | |
| 1440 $UMULH r9,r6,r7 | |
| 1441 addc r12,r12,r8 | |
| 1442 adde r10,r10,r9 | |
| 1443 addze r11,r11 | |
| 1444 #mul_add_c(a[6],b[5],c3,c1,c2); | |
| 1445 $LD r6,`6*$BNSZ`(r4) | |
| 1446 $LD r7,`5*$BNSZ`(r5) | |
| 1447 $UMULL r8,r6,r7 | |
| 1448 $UMULH r9,r6,r7 | |
| 1449 addc r12,r12,r8 | |
| 1450 adde r10,r10,r9 | |
| 1451 addze r11,r11 | |
| 1452 #mul_add_c(a[7],b[4],c3,c1,c2); | |
| 1453 $LD r6,`7*$BNSZ`(r4) | |
| 1454 $LD r7,`4*$BNSZ`(r5) | |
| 1455 $UMULL r8,r6,r7 | |
| 1456 $UMULH r9,r6,r7 | |
| 1457 addc r12,r12,r8 | |
| 1458 adde r10,r10,r9 | |
| 1459 addze r11,r11 | |
| 1460 $ST r12,`11*$BNSZ`(r3) #r[11]=c3; | |
| 1461 #mul_add_c(a[7],b[5],c1,c2,c3); | |
| 1462 $LD r7,`5*$BNSZ`(r5) | |
| 1463 $UMULL r8,r6,r7 | |
| 1464 $UMULH r9,r6,r7 | |
| 1465 addc r10,r10,r8 | |
| 1466 adde r11,r11,r9 | |
| 1467 addze r12,r0 | |
| 1468 #mul_add_c(a[6],b[6],c1,c2,c3); | |
| 1469 $LD r6,`6*$BNSZ`(r4) | |
| 1470 $LD r7,`6*$BNSZ`(r5) | |
| 1471 $UMULL r8,r6,r7 | |
| 1472 $UMULH r9,r6,r7 | |
| 1473 addc r10,r10,r8 | |
| 1474 adde r11,r11,r9 | |
| 1475 addze r12,r12 | |
| 1476 #mul_add_c(a[5],b[7],c1,c2,c3); | |
| 1477 $LD r6,`5*$BNSZ`(r4) | |
| 1478 $LD r7,`7*$BNSZ`(r5) | |
| 1479 $UMULL r8,r6,r7 | |
| 1480 $UMULH r9,r6,r7 | |
| 1481 addc r10,r10,r8 | |
| 1482 adde r11,r11,r9 | |
| 1483 addze r12,r12 | |
| 1484 $ST r10,`12*$BNSZ`(r3) #r[12]=c1; | |
| 1485 #mul_add_c(a[6],b[7],c2,c3,c1); | |
| 1486 $LD r6,`6*$BNSZ`(r4) | |
| 1487 $UMULL r8,r6,r7 | |
| 1488 $UMULH r9,r6,r7 | |
| 1489 addc r11,r11,r8 | |
| 1490 adde r12,r12,r9 | |
| 1491 addze r10,r0 | |
| 1492 #mul_add_c(a[7],b[6],c2,c3,c1); | |
| 1493 $LD r6,`7*$BNSZ`(r4) | |
| 1494 $LD r7,`6*$BNSZ`(r5) | |
| 1495 $UMULL r8,r6,r7 | |
| 1496 $UMULH r9,r6,r7 | |
| 1497 addc r11,r11,r8 | |
| 1498 adde r12,r12,r9 | |
| 1499 addze r10,r10 | |
| 1500 $ST r11,`13*$BNSZ`(r3) #r[13]=c2; | |
| 1501 #mul_add_c(a[7],b[7],c3,c1,c2); | |
| 1502 $LD r7,`7*$BNSZ`(r5) | |
| 1503 $UMULL r8,r6,r7 | |
| 1504 $UMULH r9,r6,r7 | |
| 1505 addc r12,r12,r8 | |
| 1506 adde r10,r10,r9 | |
| 1507 $ST r12,`14*$BNSZ`(r3) #r[14]=c3; | |
| 1508 $ST r10,`15*$BNSZ`(r3) #r[15]=c1; | |
| 1509 blr | |
| 1510 .long 0 | |
| 1511 .byte 0,12,0x14,0,0,0,3,0 | |
| 1512 .long 0 | |
| 1513 | |
| 1514 # | |
| 1515 # NOTE: The following label name should be changed to | |
| 1516 # "bn_sub_words" i.e. remove the first dot | |
| 1517 # for the gcc compiler. This should be automatically | |
| 1518 # done in the build | |
| 1519 # | |
| 1520 # | |
| 1521 .align 4 | |
| 1522 .bn_sub_words: | |
| 1523 # | |
| 1524 # Handcoded version of bn_sub_words | |
| 1525 # | |
| 1526 #BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) | |
| 1527 # | |
| 1528 # r3 = r | |
| 1529 # r4 = a | |
| 1530 # r5 = b | |
| 1531 # r6 = n | |
| 1532 # | |
| 1533 # Note: No loop unrolling done since this is not a performance | |
| 1534 # critical loop. | |
| 1535 | |
| 1536 xor r0,r0,r0 #set r0 = 0 | |
| 1537 # | |
| 1538 # check for r6 = 0 AND set carry bit. | |
| 1539 # | |
| 1540 subfc. r7,r0,r6 # If r6 is 0 then result is 0. | |
| 1541 # if r6 > 0 then result !=0 | |
| 1542 # In either case carry bit is set. | |
| 1543 beq Lppcasm_sub_adios | |
| 1544 addi r4,r4,-$BNSZ | |
| 1545 addi r3,r3,-$BNSZ | |
| 1546 addi r5,r5,-$BNSZ | |
| 1547 mtctr r6 | |
| 1548 Lppcasm_sub_mainloop: | |
| 1549 $LDU r7,$BNSZ(r4) | |
| 1550 $LDU r8,$BNSZ(r5) | |
| 1551 subfe r6,r8,r7 # r6 = r7+carry bit + onescomplement(r8) | |
| 1552 # if carry = 1 this is r7-r8. Else it | |
| 1553 # is r7-r8 -1 as we need. | |
| 1554 $STU r6,$BNSZ(r3) | |
| 1555 bdnz- Lppcasm_sub_mainloop | |
| 1556 Lppcasm_sub_adios: | |
| 1557 subfze r3,r0 # if carry bit is set then r3 = 0 else -1 | |
| 1558 andi. r3,r3,1 # keep only last bit. | |
| 1559 blr | |
| 1560 .long 0 | |
| 1561 .byte 0,12,0x14,0,0,0,4,0 | |
| 1562 .long 0 | |
| 1563 | |
| 1564 # | |
| 1565 # NOTE: The following label name should be changed to | |
| 1566 # "bn_add_words" i.e. remove the first dot | |
| 1567 # for the gcc compiler. This should be automatically | |
| 1568 # done in the build | |
| 1569 # | |
| 1570 | |
| 1571 .align 4 | |
| 1572 .bn_add_words: | |
| 1573 # | |
| 1574 # Handcoded version of bn_add_words | |
| 1575 # | |
| 1576 #BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) | |
| 1577 # | |
| 1578 # r3 = r | |
| 1579 # r4 = a | |
| 1580 # r5 = b | |
| 1581 # r6 = n | |
| 1582 # | |
| 1583 # Note: No loop unrolling done since this is not a performance | |
| 1584 # critical loop. | |
| 1585 | |
| 1586 xor r0,r0,r0 | |
| 1587 # | |
| 1588 # check for r6 = 0. Is this needed? | |
| 1589 # | |
| 1590 addic. r6,r6,0 #test r6 and clear carry bit. | |
| 1591 beq Lppcasm_add_adios | |
| 1592 addi r4,r4,-$BNSZ | |
| 1593 addi r3,r3,-$BNSZ | |
| 1594 addi r5,r5,-$BNSZ | |
| 1595 mtctr r6 | |
| 1596 Lppcasm_add_mainloop: | |
| 1597 $LDU r7,$BNSZ(r4) | |
| 1598 $LDU r8,$BNSZ(r5) | |
| 1599 adde r8,r7,r8 | |
| 1600 $STU r8,$BNSZ(r3) | |
| 1601 bdnz- Lppcasm_add_mainloop | |
| 1602 Lppcasm_add_adios: | |
| 1603 addze r3,r0 #return carry bit. | |
| 1604 blr | |
| 1605 .long 0 | |
| 1606 .byte 0,12,0x14,0,0,0,4,0 | |
| 1607 .long 0 | |
| 1608 | |
| 1609 # | |
| 1610 # NOTE: The following label name should be changed to | |
| 1611 # "bn_div_words" i.e. remove the first dot | |
| 1612 # for the gcc compiler. This should be automatically | |
| 1613 # done in the build | |
| 1614 # | |
| 1615 | |
| 1616 .align 4 | |
| 1617 .bn_div_words: | |
| 1618 # | |
| 1619 # This is a cleaned up version of code generated by | |
| 1620 # the AIX compiler. The only optimization is to use | |
| 1621 # the PPC instruction to count leading zeros instead | |
| 1622 # of call to num_bits_word. Since this was compiled | |
| 1623 # only at level -O2 we can possibly squeeze it more? | |
| 1624 # | |
| 1625 # r3 = h | |
| 1626 # r4 = l | |
| 1627 # r5 = d | |
| 1628 | |
| 1629 $UCMPI 0,r5,0 # compare r5 and 0 | |
| 1630 bne Lppcasm_div1 # proceed if d!=0 | |
| 1631 li r3,-1 # d=0 return -1 | |
| 1632 blr | |
| 1633 Lppcasm_div1: | |
| 1634 xor r0,r0,r0 #r0=0 | |
| 1635 li r8,$BITS | |
| 1636 $CNTLZ. r7,r5 #r7 = num leading 0s in d. | |
| 1637 beq Lppcasm_div2 #proceed if no leading zeros | |
| 1638 subf r8,r7,r8 #r8 = BN_num_bits_word(d) | |
| 1639 $SHR. r9,r3,r8 #are there any bits above r8'th? | |
| 1640 $TR 16,r9,r0 #if there're, signal to dump core... | |
| 1641 Lppcasm_div2: | |
| 1642 $UCMP 0,r3,r5 #h>=d? | |
| 1643 blt Lppcasm_div3 #goto Lppcasm_div3 if not | |
| 1644 subf r3,r5,r3 #h-=d ; | |
| 1645 Lppcasm_div3: #r7 = BN_BITS2-i. so r7=i | |
| 1646 cmpi 0,0,r7,0 # is (i == 0)? | |
| 1647 beq Lppcasm_div4 | |
| 1648 $SHL r3,r3,r7 # h = (h<< i) | |
| 1649 $SHR r8,r4,r8 # r8 = (l >> BN_BITS2 -i) | |
| 1650 $SHL r5,r5,r7 # d<<=i | |
| 1651 or r3,r3,r8 # h = (h<<i)|(l>>(BN_BITS2-i)) | |
| 1652 $SHL r4,r4,r7 # l <<=i | |
| 1653 Lppcasm_div4: | |
| 1654 $SHRI r9,r5,`$BITS/2` # r9 = dh | |
| 1655 # dl will be computed when needed | |
| 1656 # as it saves registers. | |
| 1657 li r6,2 #r6=2 | |
| 1658 mtctr r6 #counter will be in count. | |
| 1659 Lppcasm_divouterloop: | |
| 1660 $SHRI r8,r3,`$BITS/2` #r8 = (h>>BN_BITS4) | |
| 1661 $SHRI r11,r4,`$BITS/2` #r11= (l&BN_MASK2h)>>BN_BITS4 | |
| 1662 # compute here for innerloop. | |
| 1663 $UCMP 0,r8,r9 # is (h>>BN_BITS4)==dh | |
| 1664 bne Lppcasm_div5 # goto Lppcasm_div5 if not | |
| 1665 | |
| 1666 li r8,-1 | |
| 1667 $CLRU r8,r8,`$BITS/2` #q = BN_MASK2l | |
| 1668 b Lppcasm_div6 | |
| 1669 Lppcasm_div5: | |
| 1670 $UDIV r8,r3,r9 #q = h/dh | |
| 1671 Lppcasm_div6: | |
| 1672 $UMULL r12,r9,r8 #th = q*dh | |
| 1673 $CLRU r10,r5,`$BITS/2` #r10=dl | |
| 1674 $UMULL r6,r8,r10 #tl = q*dl | |
| 1675 | |
| 1676 Lppcasm_divinnerloop: | |
| 1677 subf r10,r12,r3 #t = h -th | |
| 1678 $SHRI r7,r10,`$BITS/2` #r7= (t &BN_MASK2H), sort of... | |
| 1679 addic. r7,r7,0 #test if r7 == 0. used below. | |
| 1680 # now want to compute | |
| 1681 # r7 = (t<<BN_BITS4)|((l&BN_MASK2h)>>BN_
BITS4) | |
| 1682 # the following 2 instructions do that | |
| 1683 $SHLI r7,r10,`$BITS/2` # r7 = (t<<BN_BITS4) | |
| 1684 or r7,r7,r11 # r7|=((l&BN_MASK2h)>>BN_BITS4) | |
| 1685 $UCMP cr1,r6,r7 # compare (tl <= r7) | |
| 1686 bne Lppcasm_divinnerexit | |
| 1687 ble cr1,Lppcasm_divinnerexit | |
| 1688 addi r8,r8,-1 #q-- | |
| 1689 subf r12,r9,r12 #th -=dh | |
| 1690 $CLRU r10,r5,`$BITS/2` #r10=dl. t is no longer needed in loop. | |
| 1691 subf r6,r10,r6 #tl -=dl | |
| 1692 b Lppcasm_divinnerloop | |
| 1693 Lppcasm_divinnerexit: | |
| 1694 $SHRI r10,r6,`$BITS/2` #t=(tl>>BN_BITS4) | |
| 1695 $SHLI r11,r6,`$BITS/2` #tl=(tl<<BN_BITS4)&BN_MASK2h; | |
| 1696 $UCMP cr1,r4,r11 # compare l and tl | |
| 1697 add r12,r12,r10 # th+=t | |
| 1698 bge cr1,Lppcasm_div7 # if (l>=tl) goto Lppcasm_div7 | |
| 1699 addi r12,r12,1 # th++ | |
| 1700 Lppcasm_div7: | |
| 1701 subf r11,r11,r4 #r11=l-tl | |
| 1702 $UCMP cr1,r3,r12 #compare h and th | |
| 1703 bge cr1,Lppcasm_div8 #if (h>=th) goto Lppcasm_div8 | |
| 1704 addi r8,r8,-1 # q-- | |
| 1705 add r3,r5,r3 # h+=d | |
| 1706 Lppcasm_div8: | |
| 1707 subf r12,r12,r3 #r12 = h-th | |
| 1708 $SHLI r4,r11,`$BITS/2` #l=(l&BN_MASK2l)<<BN_BITS4 | |
| 1709 # want to compute | |
| 1710 # h = ((h<<BN_BITS4)|(l>>BN_BITS4))&BN_M
ASK2 | |
| 1711 # the following 2 instructions will do t
his. | |
| 1712 $INSR r11,r12,`$BITS/2`,`$BITS/2` # r11 is the value we want rotat
ed $BITS/2. | |
| 1713 $ROTL r3,r11,`$BITS/2` # rotate by $BITS/2 and store in r3 | |
| 1714 bdz Lppcasm_div9 #if (count==0) break ; | |
| 1715 $SHLI r0,r8,`$BITS/2` #ret =q<<BN_BITS4 | |
| 1716 b Lppcasm_divouterloop | |
| 1717 Lppcasm_div9: | |
| 1718 or r3,r8,r0 | |
| 1719 blr | |
| 1720 .long 0 | |
| 1721 .byte 0,12,0x14,0,0,0,3,0 | |
| 1722 .long 0 | |
| 1723 | |
| 1724 # | |
| 1725 # NOTE: The following label name should be changed to | |
| 1726 # "bn_sqr_words" i.e. remove the first dot | |
| 1727 # for the gcc compiler. This should be automatically | |
| 1728 # done in the build | |
| 1729 # | |
| 1730 .align 4 | |
| 1731 .bn_sqr_words: | |
| 1732 # | |
| 1733 # Optimized version of bn_sqr_words | |
| 1734 # | |
| 1735 # void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n) | |
| 1736 # | |
| 1737 # r3 = r | |
| 1738 # r4 = a | |
| 1739 # r5 = n | |
| 1740 # | |
| 1741 # r6 = a[i]. | |
| 1742 # r7,r8 = product. | |
| 1743 # | |
| 1744 # No unrolling done here. Not performance critical. | |
| 1745 | |
| 1746 addic. r5,r5,0 #test r5. | |
| 1747 beq Lppcasm_sqr_adios | |
| 1748 addi r4,r4,-$BNSZ | |
| 1749 addi r3,r3,-$BNSZ | |
| 1750 mtctr r5 | |
| 1751 Lppcasm_sqr_mainloop: | |
| 1752 #sqr(r[0],r[1],a[0]); | |
| 1753 $LDU r6,$BNSZ(r4) | |
| 1754 $UMULL r7,r6,r6 | |
| 1755 $UMULH r8,r6,r6 | |
| 1756 $STU r7,$BNSZ(r3) | |
| 1757 $STU r8,$BNSZ(r3) | |
| 1758 bdnz- Lppcasm_sqr_mainloop | |
| 1759 Lppcasm_sqr_adios: | |
| 1760 blr | |
| 1761 .long 0 | |
| 1762 .byte 0,12,0x14,0,0,0,3,0 | |
| 1763 .long 0 | |
| 1764 | |
| 1765 # | |
| 1766 # NOTE: The following label name should be changed to | |
| 1767 # "bn_mul_words" i.e. remove the first dot | |
| 1768 # for the gcc compiler. This should be automatically | |
| 1769 # done in the build | |
| 1770 # | |
| 1771 | |
| 1772 .align 4 | |
| 1773 .bn_mul_words: | |
| 1774 # | |
| 1775 # BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) | |
| 1776 # | |
| 1777 # r3 = rp | |
| 1778 # r4 = ap | |
| 1779 # r5 = num | |
| 1780 # r6 = w | |
| 1781 xor r0,r0,r0 | |
| 1782 xor r12,r12,r12 # used for carry | |
| 1783 rlwinm. r7,r5,30,2,31 # num >> 2 | |
| 1784 beq Lppcasm_mw_REM | |
| 1785 mtctr r7 | |
| 1786 Lppcasm_mw_LOOP: | |
| 1787 #mul(rp[0],ap[0],w,c1); | |
| 1788 $LD r8,`0*$BNSZ`(r4) | |
| 1789 $UMULL r9,r6,r8 | |
| 1790 $UMULH r10,r6,r8 | |
| 1791 addc r9,r9,r12 | |
| 1792 #addze r10,r10 #carry is NOT ignored. | |
| 1793 #will be taken care of | |
| 1794 #in second spin below | |
| 1795 #using adde. | |
| 1796 $ST r9,`0*$BNSZ`(r3) | |
| 1797 #mul(rp[1],ap[1],w,c1); | |
| 1798 $LD r8,`1*$BNSZ`(r4) | |
| 1799 $UMULL r11,r6,r8 | |
| 1800 $UMULH r12,r6,r8 | |
| 1801 adde r11,r11,r10 | |
| 1802 #addze r12,r12 | |
| 1803 $ST r11,`1*$BNSZ`(r3) | |
| 1804 #mul(rp[2],ap[2],w,c1); | |
| 1805 $LD r8,`2*$BNSZ`(r4) | |
| 1806 $UMULL r9,r6,r8 | |
| 1807 $UMULH r10,r6,r8 | |
| 1808 adde r9,r9,r12 | |
| 1809 #addze r10,r10 | |
| 1810 $ST r9,`2*$BNSZ`(r3) | |
| 1811 #mul_add(rp[3],ap[3],w,c1); | |
| 1812 $LD r8,`3*$BNSZ`(r4) | |
| 1813 $UMULL r11,r6,r8 | |
| 1814 $UMULH r12,r6,r8 | |
| 1815 adde r11,r11,r10 | |
| 1816 addze r12,r12 #this spin we collect carry into | |
| 1817 #r12 | |
| 1818 $ST r11,`3*$BNSZ`(r3) | |
| 1819 | |
| 1820 addi r3,r3,`4*$BNSZ` | |
| 1821 addi r4,r4,`4*$BNSZ` | |
| 1822 bdnz- Lppcasm_mw_LOOP | |
| 1823 | |
| 1824 Lppcasm_mw_REM: | |
| 1825 andi. r5,r5,0x3 | |
| 1826 beq Lppcasm_mw_OVER | |
| 1827 #mul(rp[0],ap[0],w,c1); | |
| 1828 $LD r8,`0*$BNSZ`(r4) | |
| 1829 $UMULL r9,r6,r8 | |
| 1830 $UMULH r10,r6,r8 | |
| 1831 addc r9,r9,r12 | |
| 1832 addze r10,r10 | |
| 1833 $ST r9,`0*$BNSZ`(r3) | |
| 1834 addi r12,r10,0 | |
| 1835 | |
| 1836 addi r5,r5,-1 | |
| 1837 cmpli 0,0,r5,0 | |
| 1838 beq Lppcasm_mw_OVER | |
| 1839 | |
| 1840 | |
| 1841 #mul(rp[1],ap[1],w,c1); | |
| 1842 $LD r8,`1*$BNSZ`(r4) | |
| 1843 $UMULL r9,r6,r8 | |
| 1844 $UMULH r10,r6,r8 | |
| 1845 addc r9,r9,r12 | |
| 1846 addze r10,r10 | |
| 1847 $ST r9,`1*$BNSZ`(r3) | |
| 1848 addi r12,r10,0 | |
| 1849 | |
| 1850 addi r5,r5,-1 | |
| 1851 cmpli 0,0,r5,0 | |
| 1852 beq Lppcasm_mw_OVER | |
| 1853 | |
| 1854 #mul_add(rp[2],ap[2],w,c1); | |
| 1855 $LD r8,`2*$BNSZ`(r4) | |
| 1856 $UMULL r9,r6,r8 | |
| 1857 $UMULH r10,r6,r8 | |
| 1858 addc r9,r9,r12 | |
| 1859 addze r10,r10 | |
| 1860 $ST r9,`2*$BNSZ`(r3) | |
| 1861 addi r12,r10,0 | |
| 1862 | |
| 1863 Lppcasm_mw_OVER: | |
| 1864 addi r3,r12,0 | |
| 1865 blr | |
| 1866 .long 0 | |
| 1867 .byte 0,12,0x14,0,0,0,4,0 | |
| 1868 .long 0 | |
| 1869 | |
| 1870 # | |
| 1871 # NOTE: The following label name should be changed to | |
| 1872 # "bn_mul_add_words" i.e. remove the first dot | |
| 1873 # for the gcc compiler. This should be automatically | |
| 1874 # done in the build | |
| 1875 # | |
| 1876 | |
| 1877 .align 4 | |
| 1878 .bn_mul_add_words: | |
| 1879 # | |
| 1880 # BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) | |
| 1881 # | |
| 1882 # r3 = rp | |
| 1883 # r4 = ap | |
| 1884 # r5 = num | |
| 1885 # r6 = w | |
| 1886 # | |
| 1887 # empirical evidence suggests that unrolled version performs best!! | |
| 1888 # | |
| 1889 xor r0,r0,r0 #r0 = 0 | |
| 1890 xor r12,r12,r12 #r12 = 0 . used for carry | |
| 1891 rlwinm. r7,r5,30,2,31 # num >> 2 | |
| 1892 beq Lppcasm_maw_leftover # if (num < 4) go LPPCASM_maw_leftover | |
| 1893 mtctr r7 | |
| 1894 Lppcasm_maw_mainloop: | |
| 1895 #mul_add(rp[0],ap[0],w,c1); | |
| 1896 $LD r8,`0*$BNSZ`(r4) | |
| 1897 $LD r11,`0*$BNSZ`(r3) | |
| 1898 $UMULL r9,r6,r8 | |
| 1899 $UMULH r10,r6,r8 | |
| 1900 addc r9,r9,r12 #r12 is carry. | |
| 1901 addze r10,r10 | |
| 1902 addc r9,r9,r11 | |
| 1903 #addze r10,r10 | |
| 1904 #the above instruction addze | |
| 1905 #is NOT needed. Carry will NOT | |
| 1906 #be ignored. It's not affected | |
| 1907 #by multiply and will be collected | |
| 1908 #in the next spin | |
| 1909 $ST r9,`0*$BNSZ`(r3) | |
| 1910 | |
| 1911 #mul_add(rp[1],ap[1],w,c1); | |
| 1912 $LD r8,`1*$BNSZ`(r4) | |
| 1913 $LD r9,`1*$BNSZ`(r3) | |
| 1914 $UMULL r11,r6,r8 | |
| 1915 $UMULH r12,r6,r8 | |
| 1916 adde r11,r11,r10 #r10 is carry. | |
| 1917 addze r12,r12 | |
| 1918 addc r11,r11,r9 | |
| 1919 #addze r12,r12 | |
| 1920 $ST r11,`1*$BNSZ`(r3) | |
| 1921 | |
| 1922 #mul_add(rp[2],ap[2],w,c1); | |
| 1923 $LD r8,`2*$BNSZ`(r4) | |
| 1924 $UMULL r9,r6,r8 | |
| 1925 $LD r11,`2*$BNSZ`(r3) | |
| 1926 $UMULH r10,r6,r8 | |
| 1927 adde r9,r9,r12 | |
| 1928 addze r10,r10 | |
| 1929 addc r9,r9,r11 | |
| 1930 #addze r10,r10 | |
| 1931 $ST r9,`2*$BNSZ`(r3) | |
| 1932 | |
| 1933 #mul_add(rp[3],ap[3],w,c1); | |
| 1934 $LD r8,`3*$BNSZ`(r4) | |
| 1935 $UMULL r11,r6,r8 | |
| 1936 $LD r9,`3*$BNSZ`(r3) | |
| 1937 $UMULH r12,r6,r8 | |
| 1938 adde r11,r11,r10 | |
| 1939 addze r12,r12 | |
| 1940 addc r11,r11,r9 | |
| 1941 addze r12,r12 | |
| 1942 $ST r11,`3*$BNSZ`(r3) | |
| 1943 addi r3,r3,`4*$BNSZ` | |
| 1944 addi r4,r4,`4*$BNSZ` | |
| 1945 bdnz- Lppcasm_maw_mainloop | |
| 1946 | |
| 1947 Lppcasm_maw_leftover: | |
| 1948 andi. r5,r5,0x3 | |
| 1949 beq Lppcasm_maw_adios | |
| 1950 addi r3,r3,-$BNSZ | |
| 1951 addi r4,r4,-$BNSZ | |
| 1952 #mul_add(rp[0],ap[0],w,c1); | |
| 1953 mtctr r5 | |
| 1954 $LDU r8,$BNSZ(r4) | |
| 1955 $UMULL r9,r6,r8 | |
| 1956 $UMULH r10,r6,r8 | |
| 1957 $LDU r11,$BNSZ(r3) | |
| 1958 addc r9,r9,r11 | |
| 1959 addze r10,r10 | |
| 1960 addc r9,r9,r12 | |
| 1961 addze r12,r10 | |
| 1962 $ST r9,0(r3) | |
| 1963 | |
| 1964 bdz Lppcasm_maw_adios | |
| 1965 #mul_add(rp[1],ap[1],w,c1); | |
| 1966 $LDU r8,$BNSZ(r4) | |
| 1967 $UMULL r9,r6,r8 | |
| 1968 $UMULH r10,r6,r8 | |
| 1969 $LDU r11,$BNSZ(r3) | |
| 1970 addc r9,r9,r11 | |
| 1971 addze r10,r10 | |
| 1972 addc r9,r9,r12 | |
| 1973 addze r12,r10 | |
| 1974 $ST r9,0(r3) | |
| 1975 | |
| 1976 bdz Lppcasm_maw_adios | |
| 1977 #mul_add(rp[2],ap[2],w,c1); | |
| 1978 $LDU r8,$BNSZ(r4) | |
| 1979 $UMULL r9,r6,r8 | |
| 1980 $UMULH r10,r6,r8 | |
| 1981 $LDU r11,$BNSZ(r3) | |
| 1982 addc r9,r9,r11 | |
| 1983 addze r10,r10 | |
| 1984 addc r9,r9,r12 | |
| 1985 addze r12,r10 | |
| 1986 $ST r9,0(r3) | |
| 1987 | |
| 1988 Lppcasm_maw_adios: | |
| 1989 addi r3,r12,0 | |
| 1990 blr | |
| 1991 .long 0 | |
| 1992 .byte 0,12,0x14,0,0,0,4,0 | |
| 1993 .long 0 | |
| 1994 .align 4 | |
| 1995 EOF | |
| 1996 $data =~ s/\`([^\`]*)\`/eval $1/gem; | |
| 1997 print $data; | |
| 1998 close STDOUT; | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2072073002:
Delete bundled copy of OpenSSL and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master