| OLD | NEW |
|---|
| (Empty) |
| 1 ; | |
| 2 ; PA-RISC 64-bit implementation of bn_asm code | |
| 3 ; | |
| 4 ; This code is approximately 2x faster than the C version | |
| 5 ; for RSA/DSA. | |
| 6 ; | |
| 7 ; See http://devresource.hp.com/ for more details on the PA-RISC | |
| 8 ; architecture. Also see the book "PA-RISC 2.0 Architecture" | |
| 9 ; by Gerry Kane for information on the instruction set architecture. | |
| 10 ; | |
| 11 ; Code written by Chris Ruemmler (with some help from the HP C | |
| 12 ; compiler). | |
| 13 ; | |
| 14 ; The code compiles with HP's assembler | |
| 15 ; | |
| 16 | |
| 17 .level 2.0W | |
| 18 .space $TEXT$ | |
| 19 .subspa $CODE$,QUAD=0,ALIGN=8,ACCESS=0x2c,CODE_ONLY | |
| 20 | |
| 21 ; | |
| 22 ; Global Register definitions used for the routines. | |
| 23 ; | |
| 24 ; Some information about HP's runtime architecture for 64-bits. | |
| 25 ; | |
| 26 ; "Caller save" means the calling function must save the register | |
| 27 ; if it wants the register to be preserved. | |
| 28 ; "Callee save" means if a function uses the register, it must save | |
| 29 ; the value before using it. | |
| 30 ; | |
| 31 ; For the floating point registers | |
| 32 ; | |
| 33 ; "caller save" registers: fr4-fr11, fr22-fr31 | |
| 34 ; "callee save" registers: fr12-fr21 | |
| 35 ; "special" registers: fr0-fr3 (status and exception registers) | |
| 36 ; | |
| 37 ; For the integer registers | |
| 38 ; value zero : r0 | |
| 39 ; "caller save" registers: r1,r19-r26 | |
| 40 ; "callee save" registers: r3-r18 | |
| 41 ; return register : r2 (rp) | |
| 42 ; return values ; r28 (ret0,ret1) | |
| 43 ; Stack pointer ; r30 (sp) | |
| 44 ; global data pointer ; r27 (dp) | |
| 45 ; argument pointer ; r29 (ap) | |
| 46 ; millicode return ptr ; r31 (also a caller save register) | |
| 47 | |
| 48 | |
| 49 ; | |
| 50 ; Arguments to the routines | |
| 51 ; | |
| 52 r_ptr .reg %r26 | |
| 53 a_ptr .reg %r25 | |
| 54 b_ptr .reg %r24 | |
| 55 num .reg %r24 | |
| 56 w .reg %r23 | |
| 57 n .reg %r23 | |
| 58 | |
| 59 | |
| 60 ; | |
| 61 ; Globals used in some routines | |
| 62 ; | |
| 63 | |
| 64 top_overflow .reg %r29 | |
| 65 high_mask .reg %r22 ; value 0xffffffff80000000L | |
| 66 | |
| 67 | |
| 68 ;------------------------------------------------------------------------------ | |
| 69 ; | |
| 70 ; bn_mul_add_words | |
| 71 ; | |
| 72 ;BN_ULONG bn_mul_add_words(BN_ULONG *r_ptr, BN_ULONG *a_ptr, | |
| 73 ; int num, BN_ULON
G w) | |
| 74 ; | |
| 75 ; arg0 = r_ptr | |
| 76 ; arg1 = a_ptr | |
| 77 ; arg2 = num | |
| 78 ; arg3 = w | |
| 79 ; | |
| 80 ; Local register definitions | |
| 81 ; | |
| 82 | |
| 83 fm1 .reg %fr22 | |
| 84 fm .reg %fr23 | |
| 85 ht_temp .reg %fr24 | |
| 86 ht_temp_1 .reg %fr25 | |
| 87 lt_temp .reg %fr26 | |
| 88 lt_temp_1 .reg %fr27 | |
| 89 fm1_1 .reg %fr28 | |
| 90 fm_1 .reg %fr29 | |
| 91 | |
| 92 fw_h .reg %fr7L | |
| 93 fw_l .reg %fr7R | |
| 94 fw .reg %fr7 | |
| 95 | |
| 96 fht_0 .reg %fr8L | |
| 97 flt_0 .reg %fr8R | |
| 98 t_float_0 .reg %fr8 | |
| 99 | |
| 100 fht_1 .reg %fr9L | |
| 101 flt_1 .reg %fr9R | |
| 102 t_float_1 .reg %fr9 | |
| 103 | |
| 104 tmp_0 .reg %r31 | |
| 105 tmp_1 .reg %r21 | |
| 106 m_0 .reg %r20 | |
| 107 m_1 .reg %r19 | |
| 108 ht_0 .reg %r1 | |
| 109 ht_1 .reg %r3 | |
| 110 lt_0 .reg %r4 | |
| 111 lt_1 .reg %r5 | |
| 112 m1_0 .reg %r6 | |
| 113 m1_1 .reg %r7 | |
| 114 rp_val .reg %r8 | |
| 115 rp_val_1 .reg %r9 | |
| 116 | |
| 117 bn_mul_add_words | |
| 118 .export bn_mul_add_words,entry,NO_RELOCATION,LONG_RETURN | |
| 119 .proc | |
| 120 .callinfo frame=128 | |
| 121 .entry | |
| 122 .align 64 | |
| 123 | |
| 124 STD %r3,0(%sp) ; save r3 | |
| 125 STD %r4,8(%sp) ; save r4 | |
| 126 NOP ; Needed to make the loop 16-byte aligned | |
| 127 NOP ; Needed to make the loop 16-byte aligned | |
| 128 | |
| 129 STD %r5,16(%sp) ; save r5 | |
| 130 STD %r6,24(%sp) ; save r6 | |
| 131 STD %r7,32(%sp) ; save r7 | |
| 132 STD %r8,40(%sp) ; save r8 | |
| 133 | |
| 134 STD %r9,48(%sp) ; save r9 | |
| 135 COPY %r0,%ret0 ; return 0 by default | |
| 136 DEPDI,Z 1,31,1,top_overflow ; top_overflow = 1 << 32 | |
| 137 STD w,56(%sp) ; store w on stack | |
| 138 | |
| 139 CMPIB,>= 0,num,bn_mul_add_words_exit ; if (num <= 0) then exit | |
| 140 LDO 128(%sp),%sp ; bump stack | |
| 141 | |
| 142 ; | |
| 143 ; The loop is unrolled twice, so if there is only 1 number | |
| 144 ; then go straight to the cleanup code. | |
| 145 ; | |
| 146 CMPIB,= 1,num,bn_mul_add_words_single_top | |
| 147 FLDD -72(%sp),fw ; load up w into fp register fw (fw_h/fw_l) | |
| 148 | |
| 149 ; | |
| 150 ; This loop is unrolled 2 times (64-byte aligned as well) | |
| 151 ; | |
| 152 ; PA-RISC 2.0 chips have two fully pipelined multipliers, thus | |
| 153 ; two 32-bit mutiplies can be issued per cycle. | |
| 154 ; | |
| 155 bn_mul_add_words_unroll2 | |
| 156 | |
| 157 FLDD 0(a_ptr),t_float_0 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 158 FLDD 8(a_ptr),t_float_1 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 159 LDD 0(r_ptr),rp_val ; rp[0] | |
| 160 LDD 8(r_ptr),rp_val_1 ; rp[1] | |
| 161 | |
| 162 XMPYU fht_0,fw_l,fm1 ; m1[0] = fht_0*fw_l | |
| 163 XMPYU fht_1,fw_l,fm1_1 ; m1[1] = fht_1*fw_l | |
| 164 FSTD fm1,-16(%sp) ; -16(sp) = m1[0] | |
| 165 FSTD fm1_1,-48(%sp) ; -48(sp) = m1[1] | |
| 166 | |
| 167 XMPYU flt_0,fw_h,fm ; m[0] = flt_0*fw_h | |
| 168 XMPYU flt_1,fw_h,fm_1 ; m[1] = flt_1*fw_h | |
| 169 FSTD fm,-8(%sp) ; -8(sp) = m[0] | |
| 170 FSTD fm_1,-40(%sp) ; -40(sp) = m[1] | |
| 171 | |
| 172 XMPYU fht_0,fw_h,ht_temp ; ht_temp = fht_0*fw_h | |
| 173 XMPYU fht_1,fw_h,ht_temp_1 ; ht_temp_1 = fht_1*fw_h | |
| 174 FSTD ht_temp,-24(%sp) ; -24(sp) = ht_temp | |
| 175 FSTD ht_temp_1,-56(%sp) ; -56(sp) = ht_temp_1 | |
| 176 | |
| 177 XMPYU flt_0,fw_l,lt_temp ; lt_temp = lt*fw_l | |
| 178 XMPYU flt_1,fw_l,lt_temp_1 ; lt_temp = lt*fw_l | |
| 179 FSTD lt_temp,-32(%sp) ; -32(sp) = lt_temp | |
| 180 FSTD lt_temp_1,-64(%sp) ; -64(sp) = lt_temp_1 | |
| 181 | |
| 182 LDD -8(%sp),m_0 ; m[0] | |
| 183 LDD -40(%sp),m_1 ; m[1] | |
| 184 LDD -16(%sp),m1_0 ; m1[0] | |
| 185 LDD -48(%sp),m1_1 ; m1[1] | |
| 186 | |
| 187 LDD -24(%sp),ht_0 ; ht[0] | |
| 188 LDD -56(%sp),ht_1 ; ht[1] | |
| 189 ADD,L m1_0,m_0,tmp_0 ; tmp_0 = m[0] + m1[0]; | |
| 190 ADD,L m1_1,m_1,tmp_1 ; tmp_1 = m[1] + m1[1]; | |
| 191 | |
| 192 LDD -32(%sp),lt_0 | |
| 193 LDD -64(%sp),lt_1 | |
| 194 CMPCLR,*>>= tmp_0,m1_0, %r0 ; if (m[0] < m1[0]) | |
| 195 ADD,L ht_0,top_overflow,ht_0 ; ht[0] += (1<<32) | |
| 196 | |
| 197 CMPCLR,*>>= tmp_1,m1_1,%r0 ; if (m[1] < m1[1]) | |
| 198 ADD,L ht_1,top_overflow,ht_1 ; ht[1] += (1<<32) | |
| 199 EXTRD,U tmp_0,31,32,m_0 ; m[0]>>32 | |
| 200 DEPD,Z tmp_0,31,32,m1_0 ; m1[0] = m[0]<<32 | |
| 201 | |
| 202 EXTRD,U tmp_1,31,32,m_1 ; m[1]>>32 | |
| 203 DEPD,Z tmp_1,31,32,m1_1 ; m1[1] = m[1]<<32 | |
| 204 ADD,L ht_0,m_0,ht_0 ; ht[0]+= (m[0]>>32) | |
| 205 ADD,L ht_1,m_1,ht_1 ; ht[1]+= (m[1]>>32) | |
| 206 | |
| 207 ADD lt_0,m1_0,lt_0 ; lt[0] = lt[0]+m1[0]; | |
| 208 ADD,DC ht_0,%r0,ht_0 ; ht[0]++ | |
| 209 ADD lt_1,m1_1,lt_1 ; lt[1] = lt[1]+m1[1]; | |
| 210 ADD,DC ht_1,%r0,ht_1 ; ht[1]++ | |
| 211 | |
| 212 ADD %ret0,lt_0,lt_0 ; lt[0] = lt[0] + c; | |
| 213 ADD,DC ht_0,%r0,ht_0 ; ht[0]++ | |
| 214 ADD lt_0,rp_val,lt_0 ; lt[0] = lt[0]+rp[0] | |
| 215 ADD,DC ht_0,%r0,ht_0 ; ht[0]++ | |
| 216 | |
| 217 LDO -2(num),num ; num = num - 2; | |
| 218 ADD ht_0,lt_1,lt_1 ; lt[1] = lt[1] + ht_0 (c); | |
| 219 ADD,DC ht_1,%r0,ht_1 ; ht[1]++ | |
| 220 STD lt_0,0(r_ptr) ; rp[0] = lt[0] | |
| 221 | |
| 222 ADD lt_1,rp_val_1,lt_1 ; lt[1] = lt[1]+rp[1] | |
| 223 ADD,DC ht_1,%r0,%ret0 ; ht[1]++ | |
| 224 LDO 16(a_ptr),a_ptr ; a_ptr += 2 | |
| 225 | |
| 226 STD lt_1,8(r_ptr) ; rp[1] = lt[1] | |
| 227 CMPIB,<= 2,num,bn_mul_add_words_unroll2 ; go again if more to do | |
| 228 LDO 16(r_ptr),r_ptr ; r_ptr += 2 | |
| 229 | |
| 230 CMPIB,=,N 0,num,bn_mul_add_words_exit ; are we done, or cleanup last one | |
| 231 | |
| 232 ; | |
| 233 ; Top of loop aligned on 64-byte boundary | |
| 234 ; | |
| 235 bn_mul_add_words_single_top | |
| 236 FLDD 0(a_ptr),t_float_0 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 237 LDD 0(r_ptr),rp_val ; rp[0] | |
| 238 LDO 8(a_ptr),a_ptr ; a_ptr++ | |
| 239 XMPYU fht_0,fw_l,fm1 ; m1 = ht*fw_l | |
| 240 FSTD fm1,-16(%sp) ; -16(sp) = m1 | |
| 241 XMPYU flt_0,fw_h,fm ; m = lt*fw_h | |
| 242 FSTD fm,-8(%sp) ; -8(sp) = m | |
| 243 XMPYU fht_0,fw_h,ht_temp ; ht_temp = ht*fw_h | |
| 244 FSTD ht_temp,-24(%sp) ; -24(sp) = ht | |
| 245 XMPYU flt_0,fw_l,lt_temp ; lt_temp = lt*fw_l | |
| 246 FSTD lt_temp,-32(%sp) ; -32(sp) = lt | |
| 247 | |
| 248 LDD -8(%sp),m_0 | |
| 249 LDD -16(%sp),m1_0 ; m1 = temp1 | |
| 250 ADD,L m_0,m1_0,tmp_0 ; tmp_0 = m + m1; | |
| 251 LDD -24(%sp),ht_0 | |
| 252 LDD -32(%sp),lt_0 | |
| 253 | |
| 254 CMPCLR,*>>= tmp_0,m1_0,%r0 ; if (m < m1) | |
| 255 ADD,L ht_0,top_overflow,ht_0 ; ht += (1<<32) | |
| 256 | |
| 257 EXTRD,U tmp_0,31,32,m_0 ; m>>32 | |
| 258 DEPD,Z tmp_0,31,32,m1_0 ; m1 = m<<32 | |
| 259 | |
| 260 ADD,L ht_0,m_0,ht_0 ; ht+= (m>>32) | |
| 261 ADD lt_0,m1_0,tmp_0 ; tmp_0 = lt+m1; | |
| 262 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 263 ADD %ret0,tmp_0,lt_0 ; lt = lt + c; | |
| 264 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 265 ADD lt_0,rp_val,lt_0 ; lt = lt+rp[0] | |
| 266 ADD,DC ht_0,%r0,%ret0 ; ht++ | |
| 267 STD lt_0,0(r_ptr) ; rp[0] = lt | |
| 268 | |
| 269 bn_mul_add_words_exit | |
| 270 .EXIT | |
| 271 LDD -80(%sp),%r9 ; restore r9 | |
| 272 LDD -88(%sp),%r8 ; restore r8 | |
| 273 LDD -96(%sp),%r7 ; restore r7 | |
| 274 LDD -104(%sp),%r6 ; restore r6 | |
| 275 LDD -112(%sp),%r5 ; restore r5 | |
| 276 LDD -120(%sp),%r4 ; restore r4 | |
| 277 BVE (%rp) | |
| 278 LDD,MB -128(%sp),%r3 ; restore r3 | |
| 279 .PROCEND ;in=23,24,25,26,29;out=28; | |
| 280 | |
| 281 ;---------------------------------------------------------------------------- | |
| 282 ; | |
| 283 ;BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) | |
| 284 ; | |
| 285 ; arg0 = rp | |
| 286 ; arg1 = ap | |
| 287 ; arg2 = num | |
| 288 ; arg3 = w | |
| 289 | |
| 290 bn_mul_words | |
| 291 .proc | |
| 292 .callinfo frame=128 | |
| 293 .entry | |
| 294 .EXPORT bn_mul_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 295 .align 64 | |
| 296 | |
| 297 STD %r3,0(%sp) ; save r3 | |
| 298 STD %r4,8(%sp) ; save r4 | |
| 299 STD %r5,16(%sp) ; save r5 | |
| 300 STD %r6,24(%sp) ; save r6 | |
| 301 | |
| 302 STD %r7,32(%sp) ; save r7 | |
| 303 COPY %r0,%ret0 ; return 0 by default | |
| 304 DEPDI,Z 1,31,1,top_overflow ; top_overflow = 1 << 32 | |
| 305 STD w,56(%sp) ; w on stack | |
| 306 | |
| 307 CMPIB,>= 0,num,bn_mul_words_exit | |
| 308 LDO 128(%sp),%sp ; bump stack | |
| 309 | |
| 310 ; | |
| 311 ; See if only 1 word to do, thus just do cleanup | |
| 312 ; | |
| 313 CMPIB,= 1,num,bn_mul_words_single_top | |
| 314 FLDD -72(%sp),fw ; load up w into fp register fw (fw_h/fw_l) | |
| 315 | |
| 316 ; | |
| 317 ; This loop is unrolled 2 times (64-byte aligned as well) | |
| 318 ; | |
| 319 ; PA-RISC 2.0 chips have two fully pipelined multipliers, thus | |
| 320 ; two 32-bit mutiplies can be issued per cycle. | |
| 321 ; | |
| 322 bn_mul_words_unroll2 | |
| 323 | |
| 324 FLDD 0(a_ptr),t_float_0 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 325 FLDD 8(a_ptr),t_float_1 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 326 XMPYU fht_0,fw_l,fm1 ; m1[0] = fht_0*fw_l | |
| 327 XMPYU fht_1,fw_l,fm1_1 ; m1[1] = ht*fw_l | |
| 328 | |
| 329 FSTD fm1,-16(%sp) ; -16(sp) = m1 | |
| 330 FSTD fm1_1,-48(%sp) ; -48(sp) = m1 | |
| 331 XMPYU flt_0,fw_h,fm ; m = lt*fw_h | |
| 332 XMPYU flt_1,fw_h,fm_1 ; m = lt*fw_h | |
| 333 | |
| 334 FSTD fm,-8(%sp) ; -8(sp) = m | |
| 335 FSTD fm_1,-40(%sp) ; -40(sp) = m | |
| 336 XMPYU fht_0,fw_h,ht_temp ; ht_temp = fht_0*fw_h | |
| 337 XMPYU fht_1,fw_h,ht_temp_1 ; ht_temp = ht*fw_h | |
| 338 | |
| 339 FSTD ht_temp,-24(%sp) ; -24(sp) = ht | |
| 340 FSTD ht_temp_1,-56(%sp) ; -56(sp) = ht | |
| 341 XMPYU flt_0,fw_l,lt_temp ; lt_temp = lt*fw_l | |
| 342 XMPYU flt_1,fw_l,lt_temp_1 ; lt_temp = lt*fw_l | |
| 343 | |
| 344 FSTD lt_temp,-32(%sp) ; -32(sp) = lt | |
| 345 FSTD lt_temp_1,-64(%sp) ; -64(sp) = lt | |
| 346 LDD -8(%sp),m_0 | |
| 347 LDD -40(%sp),m_1 | |
| 348 | |
| 349 LDD -16(%sp),m1_0 | |
| 350 LDD -48(%sp),m1_1 | |
| 351 LDD -24(%sp),ht_0 | |
| 352 LDD -56(%sp),ht_1 | |
| 353 | |
| 354 ADD,L m1_0,m_0,tmp_0 ; tmp_0 = m + m1; | |
| 355 ADD,L m1_1,m_1,tmp_1 ; tmp_1 = m + m1; | |
| 356 LDD -32(%sp),lt_0 | |
| 357 LDD -64(%sp),lt_1 | |
| 358 | |
| 359 CMPCLR,*>>= tmp_0,m1_0, %r0 ; if (m < m1) | |
| 360 ADD,L ht_0,top_overflow,ht_0 ; ht += (1<<32) | |
| 361 CMPCLR,*>>= tmp_1,m1_1,%r0 ; if (m < m1) | |
| 362 ADD,L ht_1,top_overflow,ht_1 ; ht += (1<<32) | |
| 363 | |
| 364 EXTRD,U tmp_0,31,32,m_0 ; m>>32 | |
| 365 DEPD,Z tmp_0,31,32,m1_0 ; m1 = m<<32 | |
| 366 EXTRD,U tmp_1,31,32,m_1 ; m>>32 | |
| 367 DEPD,Z tmp_1,31,32,m1_1 ; m1 = m<<32 | |
| 368 | |
| 369 ADD,L ht_0,m_0,ht_0 ; ht+= (m>>32) | |
| 370 ADD,L ht_1,m_1,ht_1 ; ht+= (m>>32) | |
| 371 ADD lt_0,m1_0,lt_0 ; lt = lt+m1; | |
| 372 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 373 | |
| 374 ADD lt_1,m1_1,lt_1 ; lt = lt+m1; | |
| 375 ADD,DC ht_1,%r0,ht_1 ; ht++ | |
| 376 ADD %ret0,lt_0,lt_0 ; lt = lt + c (ret0); | |
| 377 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 378 | |
| 379 ADD ht_0,lt_1,lt_1 ; lt = lt + c (ht_0) | |
| 380 ADD,DC ht_1,%r0,ht_1 ; ht++ | |
| 381 STD lt_0,0(r_ptr) ; rp[0] = lt | |
| 382 STD lt_1,8(r_ptr) ; rp[1] = lt | |
| 383 | |
| 384 COPY ht_1,%ret0 ; carry = ht | |
| 385 LDO -2(num),num ; num = num - 2; | |
| 386 LDO 16(a_ptr),a_ptr ; ap += 2 | |
| 387 CMPIB,<= 2,num,bn_mul_words_unroll2 | |
| 388 LDO 16(r_ptr),r_ptr ; rp++ | |
| 389 | |
| 390 CMPIB,=,N 0,num,bn_mul_words_exit ; are we done? | |
| 391 | |
| 392 ; | |
| 393 ; Top of loop aligned on 64-byte boundary | |
| 394 ; | |
| 395 bn_mul_words_single_top | |
| 396 FLDD 0(a_ptr),t_float_0 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 397 | |
| 398 XMPYU fht_0,fw_l,fm1 ; m1 = ht*fw_l | |
| 399 FSTD fm1,-16(%sp) ; -16(sp) = m1 | |
| 400 XMPYU flt_0,fw_h,fm ; m = lt*fw_h | |
| 401 FSTD fm,-8(%sp) ; -8(sp) = m | |
| 402 XMPYU fht_0,fw_h,ht_temp ; ht_temp = ht*fw_h | |
| 403 FSTD ht_temp,-24(%sp) ; -24(sp) = ht | |
| 404 XMPYU flt_0,fw_l,lt_temp ; lt_temp = lt*fw_l | |
| 405 FSTD lt_temp,-32(%sp) ; -32(sp) = lt | |
| 406 | |
| 407 LDD -8(%sp),m_0 | |
| 408 LDD -16(%sp),m1_0 | |
| 409 ADD,L m_0,m1_0,tmp_0 ; tmp_0 = m + m1; | |
| 410 LDD -24(%sp),ht_0 | |
| 411 LDD -32(%sp),lt_0 | |
| 412 | |
| 413 CMPCLR,*>>= tmp_0,m1_0,%r0 ; if (m < m1) | |
| 414 ADD,L ht_0,top_overflow,ht_0 ; ht += (1<<32) | |
| 415 | |
| 416 EXTRD,U tmp_0,31,32,m_0 ; m>>32 | |
| 417 DEPD,Z tmp_0,31,32,m1_0 ; m1 = m<<32 | |
| 418 | |
| 419 ADD,L ht_0,m_0,ht_0 ; ht+= (m>>32) | |
| 420 ADD lt_0,m1_0,lt_0 ; lt= lt+m1; | |
| 421 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 422 | |
| 423 ADD %ret0,lt_0,lt_0 ; lt = lt + c; | |
| 424 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 425 | |
| 426 COPY ht_0,%ret0 ; copy carry | |
| 427 STD lt_0,0(r_ptr) ; rp[0] = lt | |
| 428 | |
| 429 bn_mul_words_exit | |
| 430 .EXIT | |
| 431 LDD -96(%sp),%r7 ; restore r7 | |
| 432 LDD -104(%sp),%r6 ; restore r6 | |
| 433 LDD -112(%sp),%r5 ; restore r5 | |
| 434 LDD -120(%sp),%r4 ; restore r4 | |
| 435 BVE (%rp) | |
| 436 LDD,MB -128(%sp),%r3 ; restore r3 | |
| 437 .PROCEND ;in=23,24,25,26,29;out=28; | |
| 438 | |
| 439 ;---------------------------------------------------------------------------- | |
| 440 ; | |
| 441 ;void bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num) | |
| 442 ; | |
| 443 ; arg0 = rp | |
| 444 ; arg1 = ap | |
| 445 ; arg2 = num | |
| 446 ; | |
| 447 | |
| 448 bn_sqr_words | |
| 449 .proc | |
| 450 .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE | |
| 451 .EXPORT bn_sqr_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 452 .entry | |
| 453 .align 64 | |
| 454 | |
| 455 STD %r3,0(%sp) ; save r3 | |
| 456 STD %r4,8(%sp) ; save r4 | |
| 457 NOP | |
| 458 STD %r5,16(%sp) ; save r5 | |
| 459 | |
| 460 CMPIB,>= 0,num,bn_sqr_words_exit | |
| 461 LDO 128(%sp),%sp ; bump stack | |
| 462 | |
| 463 ; | |
| 464 ; If only 1, the goto straight to cleanup | |
| 465 ; | |
| 466 CMPIB,= 1,num,bn_sqr_words_single_top | |
| 467 DEPDI,Z -1,32,33,high_mask ; Create Mask 0xffffffff80000000L | |
| 468 | |
| 469 ; | |
| 470 ; This loop is unrolled 2 times (64-byte aligned as well) | |
| 471 ; | |
| 472 | |
| 473 bn_sqr_words_unroll2 | |
| 474 FLDD 0(a_ptr),t_float_0 ; a[0] | |
| 475 FLDD 8(a_ptr),t_float_1 ; a[1] | |
| 476 XMPYU fht_0,flt_0,fm ; m[0] | |
| 477 XMPYU fht_1,flt_1,fm_1 ; m[1] | |
| 478 | |
| 479 FSTD fm,-24(%sp) ; store m[0] | |
| 480 FSTD fm_1,-56(%sp) ; store m[1] | |
| 481 XMPYU flt_0,flt_0,lt_temp ; lt[0] | |
| 482 XMPYU flt_1,flt_1,lt_temp_1 ; lt[1] | |
| 483 | |
| 484 FSTD lt_temp,-16(%sp) ; store lt[0] | |
| 485 FSTD lt_temp_1,-48(%sp) ; store lt[1] | |
| 486 XMPYU fht_0,fht_0,ht_temp ; ht[0] | |
| 487 XMPYU fht_1,fht_1,ht_temp_1 ; ht[1] | |
| 488 | |
| 489 FSTD ht_temp,-8(%sp) ; store ht[0] | |
| 490 FSTD ht_temp_1,-40(%sp) ; store ht[1] | |
| 491 LDD -24(%sp),m_0 | |
| 492 LDD -56(%sp),m_1 | |
| 493 | |
| 494 AND m_0,high_mask,tmp_0 ; m[0] & Mask | |
| 495 AND m_1,high_mask,tmp_1 ; m[1] & Mask | |
| 496 DEPD,Z m_0,30,31,m_0 ; m[0] << 32+1 | |
| 497 DEPD,Z m_1,30,31,m_1 ; m[1] << 32+1 | |
| 498 | |
| 499 LDD -16(%sp),lt_0 | |
| 500 LDD -48(%sp),lt_1 | |
| 501 EXTRD,U tmp_0,32,33,tmp_0 ; tmp_0 = m[0]&Mask >> 32-1 | |
| 502 EXTRD,U tmp_1,32,33,tmp_1 ; tmp_1 = m[1]&Mask >> 32-1 | |
| 503 | |
| 504 LDD -8(%sp),ht_0 | |
| 505 LDD -40(%sp),ht_1 | |
| 506 ADD,L ht_0,tmp_0,ht_0 ; ht[0] += tmp_0 | |
| 507 ADD,L ht_1,tmp_1,ht_1 ; ht[1] += tmp_1 | |
| 508 | |
| 509 ADD lt_0,m_0,lt_0 ; lt = lt+m | |
| 510 ADD,DC ht_0,%r0,ht_0 ; ht[0]++ | |
| 511 STD lt_0,0(r_ptr) ; rp[0] = lt[0] | |
| 512 STD ht_0,8(r_ptr) ; rp[1] = ht[1] | |
| 513 | |
| 514 ADD lt_1,m_1,lt_1 ; lt = lt+m | |
| 515 ADD,DC ht_1,%r0,ht_1 ; ht[1]++ | |
| 516 STD lt_1,16(r_ptr) ; rp[2] = lt[1] | |
| 517 STD ht_1,24(r_ptr) ; rp[3] = ht[1] | |
| 518 | |
| 519 LDO -2(num),num ; num = num - 2; | |
| 520 LDO 16(a_ptr),a_ptr ; ap += 2 | |
| 521 CMPIB,<= 2,num,bn_sqr_words_unroll2 | |
| 522 LDO 32(r_ptr),r_ptr ; rp += 4 | |
| 523 | |
| 524 CMPIB,=,N 0,num,bn_sqr_words_exit ; are we done? | |
| 525 | |
| 526 ; | |
| 527 ; Top of loop aligned on 64-byte boundary | |
| 528 ; | |
| 529 bn_sqr_words_single_top | |
| 530 FLDD 0(a_ptr),t_float_0 ; load up 64-bit value (fr8L) ht(L)/lt(R) | |
| 531 | |
| 532 XMPYU fht_0,flt_0,fm ; m | |
| 533 FSTD fm,-24(%sp) ; store m | |
| 534 | |
| 535 XMPYU flt_0,flt_0,lt_temp ; lt | |
| 536 FSTD lt_temp,-16(%sp) ; store lt | |
| 537 | |
| 538 XMPYU fht_0,fht_0,ht_temp ; ht | |
| 539 FSTD ht_temp,-8(%sp) ; store ht | |
| 540 | |
| 541 LDD -24(%sp),m_0 ; load m | |
| 542 AND m_0,high_mask,tmp_0 ; m & Mask | |
| 543 DEPD,Z m_0,30,31,m_0 ; m << 32+1 | |
| 544 LDD -16(%sp),lt_0 ; lt | |
| 545 | |
| 546 LDD -8(%sp),ht_0 ; ht | |
| 547 EXTRD,U tmp_0,32,33,tmp_0 ; tmp_0 = m&Mask >> 32-1 | |
| 548 ADD m_0,lt_0,lt_0 ; lt = lt+m | |
| 549 ADD,L ht_0,tmp_0,ht_0 ; ht += tmp_0 | |
| 550 ADD,DC ht_0,%r0,ht_0 ; ht++ | |
| 551 | |
| 552 STD lt_0,0(r_ptr) ; rp[0] = lt | |
| 553 STD ht_0,8(r_ptr) ; rp[1] = ht | |
| 554 | |
| 555 bn_sqr_words_exit | |
| 556 .EXIT | |
| 557 LDD -112(%sp),%r5 ; restore r5 | |
| 558 LDD -120(%sp),%r4 ; restore r4 | |
| 559 BVE (%rp) | |
| 560 LDD,MB -128(%sp),%r3 | |
| 561 .PROCEND ;in=23,24,25,26,29;out=28; | |
| 562 | |
| 563 | |
| 564 ;---------------------------------------------------------------------------- | |
| 565 ; | |
| 566 ;BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) | |
| 567 ; | |
| 568 ; arg0 = rp | |
| 569 ; arg1 = ap | |
| 570 ; arg2 = bp | |
| 571 ; arg3 = n | |
| 572 | |
| 573 t .reg %r22 | |
| 574 b .reg %r21 | |
| 575 l .reg %r20 | |
| 576 | |
| 577 bn_add_words | |
| 578 .proc | |
| 579 .entry | |
| 580 .callinfo | |
| 581 .EXPORT bn_add_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 582 .align 64 | |
| 583 | |
| 584 CMPIB,>= 0,n,bn_add_words_exit | |
| 585 COPY %r0,%ret0 ; return 0 by default | |
| 586 | |
| 587 ; | |
| 588 ; If 2 or more numbers do the loop | |
| 589 ; | |
| 590 CMPIB,= 1,n,bn_add_words_single_top | |
| 591 NOP | |
| 592 | |
| 593 ; | |
| 594 ; This loop is unrolled 2 times (64-byte aligned as well) | |
| 595 ; | |
| 596 bn_add_words_unroll2 | |
| 597 LDD 0(a_ptr),t | |
| 598 LDD 0(b_ptr),b | |
| 599 ADD t,%ret0,t ; t = t+c; | |
| 600 ADD,DC %r0,%r0,%ret0 ; set c to carry | |
| 601 ADD t,b,l ; l = t + b[0] | |
| 602 ADD,DC %ret0,%r0,%ret0 ; c+= carry | |
| 603 STD l,0(r_ptr) | |
| 604 | |
| 605 LDD 8(a_ptr),t | |
| 606 LDD 8(b_ptr),b | |
| 607 ADD t,%ret0,t ; t = t+c; | |
| 608 ADD,DC %r0,%r0,%ret0 ; set c to carry | |
| 609 ADD t,b,l ; l = t + b[0] | |
| 610 ADD,DC %ret0,%r0,%ret0 ; c+= carry | |
| 611 STD l,8(r_ptr) | |
| 612 | |
| 613 LDO -2(n),n | |
| 614 LDO 16(a_ptr),a_ptr | |
| 615 LDO 16(b_ptr),b_ptr | |
| 616 | |
| 617 CMPIB,<= 2,n,bn_add_words_unroll2 | |
| 618 LDO 16(r_ptr),r_ptr | |
| 619 | |
| 620 CMPIB,=,N 0,n,bn_add_words_exit ; are we done? | |
| 621 | |
| 622 bn_add_words_single_top | |
| 623 LDD 0(a_ptr),t | |
| 624 LDD 0(b_ptr),b | |
| 625 | |
| 626 ADD t,%ret0,t ; t = t+c; | |
| 627 ADD,DC %r0,%r0,%ret0 ; set c to carry (could use CMPCLR??) | |
| 628 ADD t,b,l ; l = t + b[0] | |
| 629 ADD,DC %ret0,%r0,%ret0 ; c+= carry | |
| 630 STD l,0(r_ptr) | |
| 631 | |
| 632 bn_add_words_exit | |
| 633 .EXIT | |
| 634 BVE (%rp) | |
| 635 NOP | |
| 636 .PROCEND ;in=23,24,25,26,29;out=28; | |
| 637 | |
| 638 ;---------------------------------------------------------------------------- | |
| 639 ; | |
| 640 ;BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) | |
| 641 ; | |
| 642 ; arg0 = rp | |
| 643 ; arg1 = ap | |
| 644 ; arg2 = bp | |
| 645 ; arg3 = n | |
| 646 | |
| 647 t1 .reg %r22 | |
| 648 t2 .reg %r21 | |
| 649 sub_tmp1 .reg %r20 | |
| 650 sub_tmp2 .reg %r19 | |
| 651 | |
| 652 | |
| 653 bn_sub_words | |
| 654 .proc | |
| 655 .callinfo | |
| 656 .EXPORT bn_sub_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 657 .entry | |
| 658 .align 64 | |
| 659 | |
| 660 CMPIB,>= 0,n,bn_sub_words_exit | |
| 661 COPY %r0,%ret0 ; return 0 by default | |
| 662 | |
| 663 ; | |
| 664 ; If 2 or more numbers do the loop | |
| 665 ; | |
| 666 CMPIB,= 1,n,bn_sub_words_single_top | |
| 667 NOP | |
| 668 | |
| 669 ; | |
| 670 ; This loop is unrolled 2 times (64-byte aligned as well) | |
| 671 ; | |
| 672 bn_sub_words_unroll2 | |
| 673 LDD 0(a_ptr),t1 | |
| 674 LDD 0(b_ptr),t2 | |
| 675 SUB t1,t2,sub_tmp1 ; t3 = t1-t2; | |
| 676 SUB sub_tmp1,%ret0,sub_tmp1 ; t3 = t3- c; | |
| 677 | |
| 678 CMPCLR,*>> t1,t2,sub_tmp2 ; clear if t1 > t2 | |
| 679 LDO 1(%r0),sub_tmp2 | |
| 680 | |
| 681 CMPCLR,*= t1,t2,%r0 | |
| 682 COPY sub_tmp2,%ret0 | |
| 683 STD sub_tmp1,0(r_ptr) | |
| 684 | |
| 685 LDD 8(a_ptr),t1 | |
| 686 LDD 8(b_ptr),t2 | |
| 687 SUB t1,t2,sub_tmp1 ; t3 = t1-t2; | |
| 688 SUB sub_tmp1,%ret0,sub_tmp1 ; t3 = t3- c; | |
| 689 CMPCLR,*>> t1,t2,sub_tmp2 ; clear if t1 > t2 | |
| 690 LDO 1(%r0),sub_tmp2 | |
| 691 | |
| 692 CMPCLR,*= t1,t2,%r0 | |
| 693 COPY sub_tmp2,%ret0 | |
| 694 STD sub_tmp1,8(r_ptr) | |
| 695 | |
| 696 LDO -2(n),n | |
| 697 LDO 16(a_ptr),a_ptr | |
| 698 LDO 16(b_ptr),b_ptr | |
| 699 | |
| 700 CMPIB,<= 2,n,bn_sub_words_unroll2 | |
| 701 LDO 16(r_ptr),r_ptr | |
| 702 | |
| 703 CMPIB,=,N 0,n,bn_sub_words_exit ; are we done? | |
| 704 | |
| 705 bn_sub_words_single_top | |
| 706 LDD 0(a_ptr),t1 | |
| 707 LDD 0(b_ptr),t2 | |
| 708 SUB t1,t2,sub_tmp1 ; t3 = t1-t2; | |
| 709 SUB sub_tmp1,%ret0,sub_tmp1 ; t3 = t3- c; | |
| 710 CMPCLR,*>> t1,t2,sub_tmp2 ; clear if t1 > t2 | |
| 711 LDO 1(%r0),sub_tmp2 | |
| 712 | |
| 713 CMPCLR,*= t1,t2,%r0 | |
| 714 COPY sub_tmp2,%ret0 | |
| 715 | |
| 716 STD sub_tmp1,0(r_ptr) | |
| 717 | |
| 718 bn_sub_words_exit | |
| 719 .EXIT | |
| 720 BVE (%rp) | |
| 721 NOP | |
| 722 .PROCEND ;in=23,24,25,26,29;out=28; | |
| 723 | |
| 724 ;------------------------------------------------------------------------------ | |
| 725 ; | |
| 726 ; unsigned long bn_div_words(unsigned long h, unsigned long l, unsigned long d) | |
| 727 ; | |
| 728 ; arg0 = h | |
| 729 ; arg1 = l | |
| 730 ; arg2 = d | |
| 731 ; | |
| 732 ; This is mainly just modified assembly from the compiler, thus the | |
| 733 ; lack of variable names. | |
| 734 ; | |
| 735 ;------------------------------------------------------------------------------ | |
| 736 bn_div_words | |
| 737 .proc | |
| 738 .callinfo CALLER,FRAME=272,ENTRY_GR=%r10,SAVE_RP,ARGS_SAVED,ORDERING_AWA
RE | |
| 739 .EXPORT bn_div_words,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 740 .IMPORT BN_num_bits_word,CODE,NO_RELOCATION | |
| 741 .IMPORT __iob,DATA | |
| 742 .IMPORT fprintf,CODE,NO_RELOCATION | |
| 743 .IMPORT abort,CODE,NO_RELOCATION | |
| 744 .IMPORT $$div2U,MILLICODE | |
| 745 .entry | |
| 746 STD %r2,-16(%r30) | |
| 747 STD,MA %r3,352(%r30) | |
| 748 STD %r4,-344(%r30) | |
| 749 STD %r5,-336(%r30) | |
| 750 STD %r6,-328(%r30) | |
| 751 STD %r7,-320(%r30) | |
| 752 STD %r8,-312(%r30) | |
| 753 STD %r9,-304(%r30) | |
| 754 STD %r10,-296(%r30) | |
| 755 | |
| 756 STD %r27,-288(%r30) ; save gp | |
| 757 | |
| 758 COPY %r24,%r3 ; save d | |
| 759 COPY %r26,%r4 ; save h (high 64-bits) | |
| 760 LDO -1(%r0),%ret0 ; return -1 by default | |
| 761 | |
| 762 CMPB,*= %r0,%arg2,$D3 ; if (d == 0) | |
| 763 COPY %r25,%r5 ; save l (low 64-bits) | |
| 764 | |
| 765 LDO -48(%r30),%r29 ; create ap | |
| 766 .CALL ;in=26,29;out=28; | |
| 767 B,L BN_num_bits_word,%r2 | |
| 768 COPY %r3,%r26 | |
| 769 LDD -288(%r30),%r27 ; restore gp | |
| 770 LDI 64,%r21 | |
| 771 | |
| 772 CMPB,= %r21,%ret0,$00000012 ;if (i == 64) (forward) | |
| 773 COPY %ret0,%r24 ; i | |
| 774 MTSARCM %r24 | |
| 775 DEPDI,Z -1,%sar,1,%r29 | |
| 776 CMPB,*<<,N %r29,%r4,bn_div_err_case ; if (h > 1<<i) (forward) | |
| 777 | |
| 778 $00000012 | |
| 779 SUBI 64,%r24,%r31 ; i = 64 - i; | |
| 780 CMPCLR,*<< %r4,%r3,%r0 ; if (h >= d) | |
| 781 SUB %r4,%r3,%r4 ; h -= d | |
| 782 CMPB,= %r31,%r0,$0000001A ; if (i) | |
| 783 COPY %r0,%r10 ; ret = 0 | |
| 784 MTSARCM %r31 ; i to shift | |
| 785 DEPD,Z %r3,%sar,64,%r3 ; d <<= i; | |
| 786 SUBI 64,%r31,%r19 ; 64 - i; redundent | |
| 787 MTSAR %r19 ; (64 -i) to shift | |
| 788 SHRPD %r4,%r5,%sar,%r4 ; l>> (64-i) | |
| 789 MTSARCM %r31 ; i to shift | |
| 790 DEPD,Z %r5,%sar,64,%r5 ; l <<= i; | |
| 791 | |
| 792 $0000001A | |
| 793 DEPDI,Z -1,31,32,%r19 | |
| 794 EXTRD,U %r3,31,32,%r6 ; dh=(d&0xfff)>>32 | |
| 795 EXTRD,U %r3,63,32,%r8 ; dl = d&0xffffff | |
| 796 LDO 2(%r0),%r9 | |
| 797 STD %r3,-280(%r30) ; "d" to stack | |
| 798 | |
| 799 $0000001C | |
| 800 DEPDI,Z -1,63,32,%r29 ; | |
| 801 EXTRD,U %r4,31,32,%r31 ; h >> 32 | |
| 802 CMPB,*=,N %r31,%r6,$D2 ; if ((h>>32) != dh)(forward) div | |
| 803 COPY %r4,%r26 | |
| 804 EXTRD,U %r4,31,32,%r25 | |
| 805 COPY %r6,%r24 | |
| 806 .CALL ;in=23,24,25,26;out=20,21,22,28,29; (MILLICALL) | |
| 807 B,L $$div2U,%r2 | |
| 808 EXTRD,U %r6,31,32,%r23 | |
| 809 DEPD %r28,31,32,%r29 | |
| 810 $D2 | |
| 811 STD %r29,-272(%r30) ; q | |
| 812 AND %r5,%r19,%r24 ; t & 0xffffffff00000000; | |
| 813 EXTRD,U %r24,31,32,%r24 ; ??? | |
| 814 FLDD -272(%r30),%fr7 ; q | |
| 815 FLDD -280(%r30),%fr8 ; d | |
| 816 XMPYU %fr8L,%fr7L,%fr10 | |
| 817 FSTD %fr10,-256(%r30) | |
| 818 XMPYU %fr8L,%fr7R,%fr22 | |
| 819 FSTD %fr22,-264(%r30) | |
| 820 XMPYU %fr8R,%fr7L,%fr11 | |
| 821 XMPYU %fr8R,%fr7R,%fr23 | |
| 822 FSTD %fr11,-232(%r30) | |
| 823 FSTD %fr23,-240(%r30) | |
| 824 LDD -256(%r30),%r28 | |
| 825 DEPD,Z %r28,31,32,%r2 | |
| 826 LDD -264(%r30),%r20 | |
| 827 ADD,L %r20,%r2,%r31 | |
| 828 LDD -232(%r30),%r22 | |
| 829 DEPD,Z %r22,31,32,%r22 | |
| 830 LDD -240(%r30),%r21 | |
| 831 B $00000024 ; enter loop | |
| 832 ADD,L %r21,%r22,%r23 | |
| 833 | |
| 834 $0000002A | |
| 835 LDO -1(%r29),%r29 | |
| 836 SUB %r23,%r8,%r23 | |
| 837 $00000024 | |
| 838 SUB %r4,%r31,%r25 | |
| 839 AND %r25,%r19,%r26 | |
| 840 CMPB,*<>,N %r0,%r26,$00000046 ; (forward) | |
| 841 DEPD,Z %r25,31,32,%r20 | |
| 842 OR %r20,%r24,%r21 | |
| 843 CMPB,*<<,N %r21,%r23,$0000002A ;(backward) | |
| 844 SUB %r31,%r6,%r31 | |
| 845 ;-------------Break path--------------------- | |
| 846 | |
| 847 $00000046 | |
| 848 DEPD,Z %r23,31,32,%r25 ;tl | |
| 849 EXTRD,U %r23,31,32,%r26 ;t | |
| 850 AND %r25,%r19,%r24 ;tl = (tl<<32)&0xfffffff0000000L | |
| 851 ADD,L %r31,%r26,%r31 ;th += t; | |
| 852 CMPCLR,*>>= %r5,%r24,%r0 ;if (l<tl) | |
| 853 LDO 1(%r31),%r31 ; th++; | |
| 854 CMPB,*<<=,N %r31,%r4,$00000036 ;if (n < th) (forward) | |
| 855 LDO -1(%r29),%r29 ;q--; | |
| 856 ADD,L %r4,%r3,%r4 ;h += d; | |
| 857 $00000036 | |
| 858 ADDIB,=,N -1,%r9,$D1 ;if (--count == 0) break (forward) | |
| 859 SUB %r5,%r24,%r28 ; l -= tl; | |
| 860 SUB %r4,%r31,%r24 ; h -= th; | |
| 861 SHRPD %r24,%r28,32,%r4 ; h = ((h<<32)|(l>>32)); | |
| 862 DEPD,Z %r29,31,32,%r10 ; ret = q<<32 | |
| 863 b $0000001C | |
| 864 DEPD,Z %r28,31,32,%r5 ; l = l << 32 | |
| 865 | |
| 866 $D1 | |
| 867 OR %r10,%r29,%r28 ; ret |= q | |
| 868 $D3 | |
| 869 LDD -368(%r30),%r2 | |
| 870 $D0 | |
| 871 LDD -296(%r30),%r10 | |
| 872 LDD -304(%r30),%r9 | |
| 873 LDD -312(%r30),%r8 | |
| 874 LDD -320(%r30),%r7 | |
| 875 LDD -328(%r30),%r6 | |
| 876 LDD -336(%r30),%r5 | |
| 877 LDD -344(%r30),%r4 | |
| 878 BVE (%r2) | |
| 879 .EXIT | |
| 880 LDD,MB -352(%r30),%r3 | |
| 881 | |
| 882 bn_div_err_case | |
| 883 MFIA %r6 | |
| 884 ADDIL L'bn_div_words-bn_div_err_case,%r6,%r1 | |
| 885 LDO R'bn_div_words-bn_div_err_case(%r1),%r6 | |
| 886 ADDIL LT'__iob,%r27,%r1 | |
| 887 LDD RT'__iob(%r1),%r26 | |
| 888 ADDIL L'C$4-bn_div_words,%r6,%r1 | |
| 889 LDO R'C$4-bn_div_words(%r1),%r25 | |
| 890 LDO 64(%r26),%r26 | |
| 891 .CALL ;in=24,25,26,29;out=28; | |
| 892 B,L fprintf,%r2 | |
| 893 LDO -48(%r30),%r29 | |
| 894 LDD -288(%r30),%r27 | |
| 895 .CALL ;in=29; | |
| 896 B,L abort,%r2 | |
| 897 LDO -48(%r30),%r29 | |
| 898 LDD -288(%r30),%r27 | |
| 899 B $D0 | |
| 900 LDD -368(%r30),%r2 | |
| 901 .PROCEND ;in=24,25,26,29;out=28; | |
| 902 | |
| 903 ;---------------------------------------------------------------------------- | |
| 904 ; | |
| 905 ; Registers to hold 64-bit values to manipulate. The "L" part | |
| 906 ; of the register corresponds to the upper 32-bits, while the "R" | |
| 907 ; part corresponds to the lower 32-bits | |
| 908 ; | |
| 909 ; Note, that when using b6 and b7, the code must save these before | |
| 910 ; using them because they are callee save registers | |
| 911 ; | |
| 912 ; | |
| 913 ; Floating point registers to use to save values that | |
| 914 ; are manipulated. These don't collide with ftemp1-6 and | |
| 915 ; are all caller save registers | |
| 916 ; | |
| 917 a0 .reg %fr22 | |
| 918 a0L .reg %fr22L | |
| 919 a0R .reg %fr22R | |
| 920 | |
| 921 a1 .reg %fr23 | |
| 922 a1L .reg %fr23L | |
| 923 a1R .reg %fr23R | |
| 924 | |
| 925 a2 .reg %fr24 | |
| 926 a2L .reg %fr24L | |
| 927 a2R .reg %fr24R | |
| 928 | |
| 929 a3 .reg %fr25 | |
| 930 a3L .reg %fr25L | |
| 931 a3R .reg %fr25R | |
| 932 | |
| 933 a4 .reg %fr26 | |
| 934 a4L .reg %fr26L | |
| 935 a4R .reg %fr26R | |
| 936 | |
| 937 a5 .reg %fr27 | |
| 938 a5L .reg %fr27L | |
| 939 a5R .reg %fr27R | |
| 940 | |
| 941 a6 .reg %fr28 | |
| 942 a6L .reg %fr28L | |
| 943 a6R .reg %fr28R | |
| 944 | |
| 945 a7 .reg %fr29 | |
| 946 a7L .reg %fr29L | |
| 947 a7R .reg %fr29R | |
| 948 | |
| 949 b0 .reg %fr30 | |
| 950 b0L .reg %fr30L | |
| 951 b0R .reg %fr30R | |
| 952 | |
| 953 b1 .reg %fr31 | |
| 954 b1L .reg %fr31L | |
| 955 b1R .reg %fr31R | |
| 956 | |
| 957 ; | |
| 958 ; Temporary floating point variables, these are all caller save | |
| 959 ; registers | |
| 960 ; | |
| 961 ftemp1 .reg %fr4 | |
| 962 ftemp2 .reg %fr5 | |
| 963 ftemp3 .reg %fr6 | |
| 964 ftemp4 .reg %fr7 | |
| 965 | |
| 966 ; | |
| 967 ; The B set of registers when used. | |
| 968 ; | |
| 969 | |
| 970 b2 .reg %fr8 | |
| 971 b2L .reg %fr8L | |
| 972 b2R .reg %fr8R | |
| 973 | |
| 974 b3 .reg %fr9 | |
| 975 b3L .reg %fr9L | |
| 976 b3R .reg %fr9R | |
| 977 | |
| 978 b4 .reg %fr10 | |
| 979 b4L .reg %fr10L | |
| 980 b4R .reg %fr10R | |
| 981 | |
| 982 b5 .reg %fr11 | |
| 983 b5L .reg %fr11L | |
| 984 b5R .reg %fr11R | |
| 985 | |
| 986 b6 .reg %fr12 | |
| 987 b6L .reg %fr12L | |
| 988 b6R .reg %fr12R | |
| 989 | |
| 990 b7 .reg %fr13 | |
| 991 b7L .reg %fr13L | |
| 992 b7R .reg %fr13R | |
| 993 | |
| 994 c1 .reg %r21 ; only reg | |
| 995 temp1 .reg %r20 ; only reg | |
| 996 temp2 .reg %r19 ; only reg | |
| 997 temp3 .reg %r31 ; only reg | |
| 998 | |
| 999 m1 .reg %r28 | |
| 1000 c2 .reg %r23 | |
| 1001 high_one .reg %r1 | |
| 1002 ht .reg %r6 | |
| 1003 lt .reg %r5 | |
| 1004 m .reg %r4 | |
| 1005 c3 .reg %r3 | |
| 1006 | |
| 1007 SQR_ADD_C .macro A0L,A0R,C1,C2,C3 | |
| 1008 XMPYU A0L,A0R,ftemp1 ; m | |
| 1009 FSTD ftemp1,-24(%sp) ; store m | |
| 1010 | |
| 1011 XMPYU A0R,A0R,ftemp2 ; lt | |
| 1012 FSTD ftemp2,-16(%sp) ; store lt | |
| 1013 | |
| 1014 XMPYU A0L,A0L,ftemp3 ; ht | |
| 1015 FSTD ftemp3,-8(%sp) ; store ht | |
| 1016 | |
| 1017 LDD -24(%sp),m ; load m | |
| 1018 AND m,high_mask,temp2 ; m & Mask | |
| 1019 DEPD,Z m,30,31,temp3 ; m << 32+1 | |
| 1020 LDD -16(%sp),lt ; lt | |
| 1021 | |
| 1022 LDD -8(%sp),ht ; ht | |
| 1023 EXTRD,U temp2,32,33,temp1 ; temp1 = m&Mask >> 32-1 | |
| 1024 ADD temp3,lt,lt ; lt = lt+m | |
| 1025 ADD,L ht,temp1,ht ; ht += temp1 | |
| 1026 ADD,DC ht,%r0,ht ; ht++ | |
| 1027 | |
| 1028 ADD C1,lt,C1 ; c1=c1+lt | |
| 1029 ADD,DC ht,%r0,ht ; ht++ | |
| 1030 | |
| 1031 ADD C2,ht,C2 ; c2=c2+ht | |
| 1032 ADD,DC C3,%r0,C3 ; c3++ | |
| 1033 .endm | |
| 1034 | |
| 1035 SQR_ADD_C2 .macro A0L,A0R,A1L,A1R,C1,C2,C3 | |
| 1036 XMPYU A0L,A1R,ftemp1 ; m1 = bl*ht | |
| 1037 FSTD ftemp1,-16(%sp) ; | |
| 1038 XMPYU A0R,A1L,ftemp2 ; m = bh*lt | |
| 1039 FSTD ftemp2,-8(%sp) ; | |
| 1040 XMPYU A0R,A1R,ftemp3 ; lt = bl*lt | |
| 1041 FSTD ftemp3,-32(%sp) | |
| 1042 XMPYU A0L,A1L,ftemp4 ; ht = bh*ht | |
| 1043 FSTD ftemp4,-24(%sp) ; | |
| 1044 | |
| 1045 LDD -8(%sp),m ; r21 = m | |
| 1046 LDD -16(%sp),m1 ; r19 = m1 | |
| 1047 ADD,L m,m1,m ; m+m1 | |
| 1048 | |
| 1049 DEPD,Z m,31,32,temp3 ; (m+m1<<32) | |
| 1050 LDD -24(%sp),ht ; r24 = ht | |
| 1051 | |
| 1052 CMPCLR,*>>= m,m1,%r0 ; if (m < m1) | |
| 1053 ADD,L ht,high_one,ht ; ht+=high_one | |
| 1054 | |
| 1055 EXTRD,U m,31,32,temp1 ; m >> 32 | |
| 1056 LDD -32(%sp),lt ; lt | |
| 1057 ADD,L ht,temp1,ht ; ht+= m>>32 | |
| 1058 ADD lt,temp3,lt ; lt = lt+m1 | |
| 1059 ADD,DC ht,%r0,ht ; ht++ | |
| 1060 | |
| 1061 ADD ht,ht,ht ; ht=ht+ht; | |
| 1062 ADD,DC C3,%r0,C3 ; add in carry (c3++) | |
| 1063 | |
| 1064 ADD lt,lt,lt ; lt=lt+lt; | |
| 1065 ADD,DC ht,%r0,ht ; add in carry (ht++) | |
| 1066 | |
| 1067 ADD C1,lt,C1 ; c1=c1+lt | |
| 1068 ADD,DC,*NUV ht,%r0,ht ; add in carry (ht++) | |
| 1069 LDO 1(C3),C3 ; bump c3 if overflow,nullify otherwise | |
| 1070 | |
| 1071 ADD C2,ht,C2 ; c2 = c2 + ht | |
| 1072 ADD,DC C3,%r0,C3 ; add in carry (c3++) | |
| 1073 .endm | |
| 1074 | |
| 1075 ; | |
| 1076 ;void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a) | |
| 1077 ; arg0 = r_ptr | |
| 1078 ; arg1 = a_ptr | |
| 1079 ; | |
| 1080 | |
| 1081 bn_sqr_comba8 | |
| 1082 .PROC | |
| 1083 .CALLINFO FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE | |
| 1084 .EXPORT bn_sqr_comba8,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 1085 .ENTRY | |
| 1086 .align 64 | |
| 1087 | |
| 1088 STD %r3,0(%sp) ; save r3 | |
| 1089 STD %r4,8(%sp) ; save r4 | |
| 1090 STD %r5,16(%sp) ; save r5 | |
| 1091 STD %r6,24(%sp) ; save r6 | |
| 1092 | |
| 1093 ; | |
| 1094 ; Zero out carries | |
| 1095 ; | |
| 1096 COPY %r0,c1 | |
| 1097 COPY %r0,c2 | |
| 1098 COPY %r0,c3 | |
| 1099 | |
| 1100 LDO 128(%sp),%sp ; bump stack | |
| 1101 DEPDI,Z -1,32,33,high_mask ; Create Mask 0xffffffff80000000L | |
| 1102 DEPDI,Z 1,31,1,high_one ; Create Value 1 << 32 | |
| 1103 | |
| 1104 ; | |
| 1105 ; Load up all of the values we are going to use | |
| 1106 ; | |
| 1107 FLDD 0(a_ptr),a0 | |
| 1108 FLDD 8(a_ptr),a1 | |
| 1109 FLDD 16(a_ptr),a2 | |
| 1110 FLDD 24(a_ptr),a3 | |
| 1111 FLDD 32(a_ptr),a4 | |
| 1112 FLDD 40(a_ptr),a5 | |
| 1113 FLDD 48(a_ptr),a6 | |
| 1114 FLDD 56(a_ptr),a7 | |
| 1115 | |
| 1116 SQR_ADD_C a0L,a0R,c1,c2,c3 | |
| 1117 STD c1,0(r_ptr) ; r[0] = c1; | |
| 1118 COPY %r0,c1 | |
| 1119 | |
| 1120 SQR_ADD_C2 a1L,a1R,a0L,a0R,c2,c3,c1 | |
| 1121 STD c2,8(r_ptr) ; r[1] = c2; | |
| 1122 COPY %r0,c2 | |
| 1123 | |
| 1124 SQR_ADD_C a1L,a1R,c3,c1,c2 | |
| 1125 SQR_ADD_C2 a2L,a2R,a0L,a0R,c3,c1,c2 | |
| 1126 STD c3,16(r_ptr) ; r[2] = c3; | |
| 1127 COPY %r0,c3 | |
| 1128 | |
| 1129 SQR_ADD_C2 a3L,a3R,a0L,a0R,c1,c2,c3 | |
| 1130 SQR_ADD_C2 a2L,a2R,a1L,a1R,c1,c2,c3 | |
| 1131 STD c1,24(r_ptr) ; r[3] = c1; | |
| 1132 COPY %r0,c1 | |
| 1133 | |
| 1134 SQR_ADD_C a2L,a2R,c2,c3,c1 | |
| 1135 SQR_ADD_C2 a3L,a3R,a1L,a1R,c2,c3,c1 | |
| 1136 SQR_ADD_C2 a4L,a4R,a0L,a0R,c2,c3,c1 | |
| 1137 STD c2,32(r_ptr) ; r[4] = c2; | |
| 1138 COPY %r0,c2 | |
| 1139 | |
| 1140 SQR_ADD_C2 a5L,a5R,a0L,a0R,c3,c1,c2 | |
| 1141 SQR_ADD_C2 a4L,a4R,a1L,a1R,c3,c1,c2 | |
| 1142 SQR_ADD_C2 a3L,a3R,a2L,a2R,c3,c1,c2 | |
| 1143 STD c3,40(r_ptr) ; r[5] = c3; | |
| 1144 COPY %r0,c3 | |
| 1145 | |
| 1146 SQR_ADD_C a3L,a3R,c1,c2,c3 | |
| 1147 SQR_ADD_C2 a4L,a4R,a2L,a2R,c1,c2,c3 | |
| 1148 SQR_ADD_C2 a5L,a5R,a1L,a1R,c1,c2,c3 | |
| 1149 SQR_ADD_C2 a6L,a6R,a0L,a0R,c1,c2,c3 | |
| 1150 STD c1,48(r_ptr) ; r[6] = c1; | |
| 1151 COPY %r0,c1 | |
| 1152 | |
| 1153 SQR_ADD_C2 a7L,a7R,a0L,a0R,c2,c3,c1 | |
| 1154 SQR_ADD_C2 a6L,a6R,a1L,a1R,c2,c3,c1 | |
| 1155 SQR_ADD_C2 a5L,a5R,a2L,a2R,c2,c3,c1 | |
| 1156 SQR_ADD_C2 a4L,a4R,a3L,a3R,c2,c3,c1 | |
| 1157 STD c2,56(r_ptr) ; r[7] = c2; | |
| 1158 COPY %r0,c2 | |
| 1159 | |
| 1160 SQR_ADD_C a4L,a4R,c3,c1,c2 | |
| 1161 SQR_ADD_C2 a5L,a5R,a3L,a3R,c3,c1,c2 | |
| 1162 SQR_ADD_C2 a6L,a6R,a2L,a2R,c3,c1,c2 | |
| 1163 SQR_ADD_C2 a7L,a7R,a1L,a1R,c3,c1,c2 | |
| 1164 STD c3,64(r_ptr) ; r[8] = c3; | |
| 1165 COPY %r0,c3 | |
| 1166 | |
| 1167 SQR_ADD_C2 a7L,a7R,a2L,a2R,c1,c2,c3 | |
| 1168 SQR_ADD_C2 a6L,a6R,a3L,a3R,c1,c2,c3 | |
| 1169 SQR_ADD_C2 a5L,a5R,a4L,a4R,c1,c2,c3 | |
| 1170 STD c1,72(r_ptr) ; r[9] = c1; | |
| 1171 COPY %r0,c1 | |
| 1172 | |
| 1173 SQR_ADD_C a5L,a5R,c2,c3,c1 | |
| 1174 SQR_ADD_C2 a6L,a6R,a4L,a4R,c2,c3,c1 | |
| 1175 SQR_ADD_C2 a7L,a7R,a3L,a3R,c2,c3,c1 | |
| 1176 STD c2,80(r_ptr) ; r[10] = c2; | |
| 1177 COPY %r0,c2 | |
| 1178 | |
| 1179 SQR_ADD_C2 a7L,a7R,a4L,a4R,c3,c1,c2 | |
| 1180 SQR_ADD_C2 a6L,a6R,a5L,a5R,c3,c1,c2 | |
| 1181 STD c3,88(r_ptr) ; r[11] = c3; | |
| 1182 COPY %r0,c3 | |
| 1183 | |
| 1184 SQR_ADD_C a6L,a6R,c1,c2,c3 | |
| 1185 SQR_ADD_C2 a7L,a7R,a5L,a5R,c1,c2,c3 | |
| 1186 STD c1,96(r_ptr) ; r[12] = c1; | |
| 1187 COPY %r0,c1 | |
| 1188 | |
| 1189 SQR_ADD_C2 a7L,a7R,a6L,a6R,c2,c3,c1 | |
| 1190 STD c2,104(r_ptr) ; r[13] = c2; | |
| 1191 COPY %r0,c2 | |
| 1192 | |
| 1193 SQR_ADD_C a7L,a7R,c3,c1,c2 | |
| 1194 STD c3, 112(r_ptr) ; r[14] = c3 | |
| 1195 STD c1, 120(r_ptr) ; r[15] = c1 | |
| 1196 | |
| 1197 .EXIT | |
| 1198 LDD -104(%sp),%r6 ; restore r6 | |
| 1199 LDD -112(%sp),%r5 ; restore r5 | |
| 1200 LDD -120(%sp),%r4 ; restore r4 | |
| 1201 BVE (%rp) | |
| 1202 LDD,MB -128(%sp),%r3 | |
| 1203 | |
| 1204 .PROCEND | |
| 1205 | |
| 1206 ;----------------------------------------------------------------------------- | |
| 1207 ; | |
| 1208 ;void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a) | |
| 1209 ; arg0 = r_ptr | |
| 1210 ; arg1 = a_ptr | |
| 1211 ; | |
| 1212 | |
| 1213 bn_sqr_comba4 | |
| 1214 .proc | |
| 1215 .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE | |
| 1216 .EXPORT bn_sqr_comba4,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 1217 .entry | |
| 1218 .align 64 | |
| 1219 STD %r3,0(%sp) ; save r3 | |
| 1220 STD %r4,8(%sp) ; save r4 | |
| 1221 STD %r5,16(%sp) ; save r5 | |
| 1222 STD %r6,24(%sp) ; save r6 | |
| 1223 | |
| 1224 ; | |
| 1225 ; Zero out carries | |
| 1226 ; | |
| 1227 COPY %r0,c1 | |
| 1228 COPY %r0,c2 | |
| 1229 COPY %r0,c3 | |
| 1230 | |
| 1231 LDO 128(%sp),%sp ; bump stack | |
| 1232 DEPDI,Z -1,32,33,high_mask ; Create Mask 0xffffffff80000000L | |
| 1233 DEPDI,Z 1,31,1,high_one ; Create Value 1 << 32 | |
| 1234 | |
| 1235 ; | |
| 1236 ; Load up all of the values we are going to use | |
| 1237 ; | |
| 1238 FLDD 0(a_ptr),a0 | |
| 1239 FLDD 8(a_ptr),a1 | |
| 1240 FLDD 16(a_ptr),a2 | |
| 1241 FLDD 24(a_ptr),a3 | |
| 1242 FLDD 32(a_ptr),a4 | |
| 1243 FLDD 40(a_ptr),a5 | |
| 1244 FLDD 48(a_ptr),a6 | |
| 1245 FLDD 56(a_ptr),a7 | |
| 1246 | |
| 1247 SQR_ADD_C a0L,a0R,c1,c2,c3 | |
| 1248 | |
| 1249 STD c1,0(r_ptr) ; r[0] = c1; | |
| 1250 COPY %r0,c1 | |
| 1251 | |
| 1252 SQR_ADD_C2 a1L,a1R,a0L,a0R,c2,c3,c1 | |
| 1253 | |
| 1254 STD c2,8(r_ptr) ; r[1] = c2; | |
| 1255 COPY %r0,c2 | |
| 1256 | |
| 1257 SQR_ADD_C a1L,a1R,c3,c1,c2 | |
| 1258 SQR_ADD_C2 a2L,a2R,a0L,a0R,c3,c1,c2 | |
| 1259 | |
| 1260 STD c3,16(r_ptr) ; r[2] = c3; | |
| 1261 COPY %r0,c3 | |
| 1262 | |
| 1263 SQR_ADD_C2 a3L,a3R,a0L,a0R,c1,c2,c3 | |
| 1264 SQR_ADD_C2 a2L,a2R,a1L,a1R,c1,c2,c3 | |
| 1265 | |
| 1266 STD c1,24(r_ptr) ; r[3] = c1; | |
| 1267 COPY %r0,c1 | |
| 1268 | |
| 1269 SQR_ADD_C a2L,a2R,c2,c3,c1 | |
| 1270 SQR_ADD_C2 a3L,a3R,a1L,a1R,c2,c3,c1 | |
| 1271 | |
| 1272 STD c2,32(r_ptr) ; r[4] = c2; | |
| 1273 COPY %r0,c2 | |
| 1274 | |
| 1275 SQR_ADD_C2 a3L,a3R,a2L,a2R,c3,c1,c2 | |
| 1276 STD c3,40(r_ptr) ; r[5] = c3; | |
| 1277 COPY %r0,c3 | |
| 1278 | |
| 1279 SQR_ADD_C a3L,a3R,c1,c2,c3 | |
| 1280 STD c1,48(r_ptr) ; r[6] = c1; | |
| 1281 STD c2,56(r_ptr) ; r[7] = c2; | |
| 1282 | |
| 1283 .EXIT | |
| 1284 LDD -104(%sp),%r6 ; restore r6 | |
| 1285 LDD -112(%sp),%r5 ; restore r5 | |
| 1286 LDD -120(%sp),%r4 ; restore r4 | |
| 1287 BVE (%rp) | |
| 1288 LDD,MB -128(%sp),%r3 | |
| 1289 | |
| 1290 .PROCEND | |
| 1291 | |
| 1292 | |
| 1293 ;--------------------------------------------------------------------------- | |
| 1294 | |
| 1295 MUL_ADD_C .macro A0L,A0R,B0L,B0R,C1,C2,C3 | |
| 1296 XMPYU A0L,B0R,ftemp1 ; m1 = bl*ht | |
| 1297 FSTD ftemp1,-16(%sp) ; | |
| 1298 XMPYU A0R,B0L,ftemp2 ; m = bh*lt | |
| 1299 FSTD ftemp2,-8(%sp) ; | |
| 1300 XMPYU A0R,B0R,ftemp3 ; lt = bl*lt | |
| 1301 FSTD ftemp3,-32(%sp) | |
| 1302 XMPYU A0L,B0L,ftemp4 ; ht = bh*ht | |
| 1303 FSTD ftemp4,-24(%sp) ; | |
| 1304 | |
| 1305 LDD -8(%sp),m ; r21 = m | |
| 1306 LDD -16(%sp),m1 ; r19 = m1 | |
| 1307 ADD,L m,m1,m ; m+m1 | |
| 1308 | |
| 1309 DEPD,Z m,31,32,temp3 ; (m+m1<<32) | |
| 1310 LDD -24(%sp),ht ; r24 = ht | |
| 1311 | |
| 1312 CMPCLR,*>>= m,m1,%r0 ; if (m < m1) | |
| 1313 ADD,L ht,high_one,ht ; ht+=high_one | |
| 1314 | |
| 1315 EXTRD,U m,31,32,temp1 ; m >> 32 | |
| 1316 LDD -32(%sp),lt ; lt | |
| 1317 ADD,L ht,temp1,ht ; ht+= m>>32 | |
| 1318 ADD lt,temp3,lt ; lt = lt+m1 | |
| 1319 ADD,DC ht,%r0,ht ; ht++ | |
| 1320 | |
| 1321 ADD C1,lt,C1 ; c1=c1+lt | |
| 1322 ADD,DC ht,%r0,ht ; bump c3 if overflow,nullify otherwise | |
| 1323 | |
| 1324 ADD C2,ht,C2 ; c2 = c2 + ht | |
| 1325 ADD,DC C3,%r0,C3 ; add in carry (c3++) | |
| 1326 .endm | |
| 1327 | |
| 1328 | |
| 1329 ; | |
| 1330 ;void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b) | |
| 1331 ; arg0 = r_ptr | |
| 1332 ; arg1 = a_ptr | |
| 1333 ; arg2 = b_ptr | |
| 1334 ; | |
| 1335 | |
| 1336 bn_mul_comba8 | |
| 1337 .proc | |
| 1338 .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE | |
| 1339 .EXPORT bn_mul_comba8,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 1340 .entry | |
| 1341 .align 64 | |
| 1342 | |
| 1343 STD %r3,0(%sp) ; save r3 | |
| 1344 STD %r4,8(%sp) ; save r4 | |
| 1345 STD %r5,16(%sp) ; save r5 | |
| 1346 STD %r6,24(%sp) ; save r6 | |
| 1347 FSTD %fr12,32(%sp) ; save r6 | |
| 1348 FSTD %fr13,40(%sp) ; save r7 | |
| 1349 | |
| 1350 ; | |
| 1351 ; Zero out carries | |
| 1352 ; | |
| 1353 COPY %r0,c1 | |
| 1354 COPY %r0,c2 | |
| 1355 COPY %r0,c3 | |
| 1356 | |
| 1357 LDO 128(%sp),%sp ; bump stack | |
| 1358 DEPDI,Z 1,31,1,high_one ; Create Value 1 << 32 | |
| 1359 | |
| 1360 ; | |
| 1361 ; Load up all of the values we are going to use | |
| 1362 ; | |
| 1363 FLDD 0(a_ptr),a0 | |
| 1364 FLDD 8(a_ptr),a1 | |
| 1365 FLDD 16(a_ptr),a2 | |
| 1366 FLDD 24(a_ptr),a3 | |
| 1367 FLDD 32(a_ptr),a4 | |
| 1368 FLDD 40(a_ptr),a5 | |
| 1369 FLDD 48(a_ptr),a6 | |
| 1370 FLDD 56(a_ptr),a7 | |
| 1371 | |
| 1372 FLDD 0(b_ptr),b0 | |
| 1373 FLDD 8(b_ptr),b1 | |
| 1374 FLDD 16(b_ptr),b2 | |
| 1375 FLDD 24(b_ptr),b3 | |
| 1376 FLDD 32(b_ptr),b4 | |
| 1377 FLDD 40(b_ptr),b5 | |
| 1378 FLDD 48(b_ptr),b6 | |
| 1379 FLDD 56(b_ptr),b7 | |
| 1380 | |
| 1381 MUL_ADD_C a0L,a0R,b0L,b0R,c1,c2,c3 | |
| 1382 STD c1,0(r_ptr) | |
| 1383 COPY %r0,c1 | |
| 1384 | |
| 1385 MUL_ADD_C a0L,a0R,b1L,b1R,c2,c3,c1 | |
| 1386 MUL_ADD_C a1L,a1R,b0L,b0R,c2,c3,c1 | |
| 1387 STD c2,8(r_ptr) | |
| 1388 COPY %r0,c2 | |
| 1389 | |
| 1390 MUL_ADD_C a2L,a2R,b0L,b0R,c3,c1,c2 | |
| 1391 MUL_ADD_C a1L,a1R,b1L,b1R,c3,c1,c2 | |
| 1392 MUL_ADD_C a0L,a0R,b2L,b2R,c3,c1,c2 | |
| 1393 STD c3,16(r_ptr) | |
| 1394 COPY %r0,c3 | |
| 1395 | |
| 1396 MUL_ADD_C a0L,a0R,b3L,b3R,c1,c2,c3 | |
| 1397 MUL_ADD_C a1L,a1R,b2L,b2R,c1,c2,c3 | |
| 1398 MUL_ADD_C a2L,a2R,b1L,b1R,c1,c2,c3 | |
| 1399 MUL_ADD_C a3L,a3R,b0L,b0R,c1,c2,c3 | |
| 1400 STD c1,24(r_ptr) | |
| 1401 COPY %r0,c1 | |
| 1402 | |
| 1403 MUL_ADD_C a4L,a4R,b0L,b0R,c2,c3,c1 | |
| 1404 MUL_ADD_C a3L,a3R,b1L,b1R,c2,c3,c1 | |
| 1405 MUL_ADD_C a2L,a2R,b2L,b2R,c2,c3,c1 | |
| 1406 MUL_ADD_C a1L,a1R,b3L,b3R,c2,c3,c1 | |
| 1407 MUL_ADD_C a0L,a0R,b4L,b4R,c2,c3,c1 | |
| 1408 STD c2,32(r_ptr) | |
| 1409 COPY %r0,c2 | |
| 1410 | |
| 1411 MUL_ADD_C a0L,a0R,b5L,b5R,c3,c1,c2 | |
| 1412 MUL_ADD_C a1L,a1R,b4L,b4R,c3,c1,c2 | |
| 1413 MUL_ADD_C a2L,a2R,b3L,b3R,c3,c1,c2 | |
| 1414 MUL_ADD_C a3L,a3R,b2L,b2R,c3,c1,c2 | |
| 1415 MUL_ADD_C a4L,a4R,b1L,b1R,c3,c1,c2 | |
| 1416 MUL_ADD_C a5L,a5R,b0L,b0R,c3,c1,c2 | |
| 1417 STD c3,40(r_ptr) | |
| 1418 COPY %r0,c3 | |
| 1419 | |
| 1420 MUL_ADD_C a6L,a6R,b0L,b0R,c1,c2,c3 | |
| 1421 MUL_ADD_C a5L,a5R,b1L,b1R,c1,c2,c3 | |
| 1422 MUL_ADD_C a4L,a4R,b2L,b2R,c1,c2,c3 | |
| 1423 MUL_ADD_C a3L,a3R,b3L,b3R,c1,c2,c3 | |
| 1424 MUL_ADD_C a2L,a2R,b4L,b4R,c1,c2,c3 | |
| 1425 MUL_ADD_C a1L,a1R,b5L,b5R,c1,c2,c3 | |
| 1426 MUL_ADD_C a0L,a0R,b6L,b6R,c1,c2,c3 | |
| 1427 STD c1,48(r_ptr) | |
| 1428 COPY %r0,c1 | |
| 1429 | |
| 1430 MUL_ADD_C a0L,a0R,b7L,b7R,c2,c3,c1 | |
| 1431 MUL_ADD_C a1L,a1R,b6L,b6R,c2,c3,c1 | |
| 1432 MUL_ADD_C a2L,a2R,b5L,b5R,c2,c3,c1 | |
| 1433 MUL_ADD_C a3L,a3R,b4L,b4R,c2,c3,c1 | |
| 1434 MUL_ADD_C a4L,a4R,b3L,b3R,c2,c3,c1 | |
| 1435 MUL_ADD_C a5L,a5R,b2L,b2R,c2,c3,c1 | |
| 1436 MUL_ADD_C a6L,a6R,b1L,b1R,c2,c3,c1 | |
| 1437 MUL_ADD_C a7L,a7R,b0L,b0R,c2,c3,c1 | |
| 1438 STD c2,56(r_ptr) | |
| 1439 COPY %r0,c2 | |
| 1440 | |
| 1441 MUL_ADD_C a7L,a7R,b1L,b1R,c3,c1,c2 | |
| 1442 MUL_ADD_C a6L,a6R,b2L,b2R,c3,c1,c2 | |
| 1443 MUL_ADD_C a5L,a5R,b3L,b3R,c3,c1,c2 | |
| 1444 MUL_ADD_C a4L,a4R,b4L,b4R,c3,c1,c2 | |
| 1445 MUL_ADD_C a3L,a3R,b5L,b5R,c3,c1,c2 | |
| 1446 MUL_ADD_C a2L,a2R,b6L,b6R,c3,c1,c2 | |
| 1447 MUL_ADD_C a1L,a1R,b7L,b7R,c3,c1,c2 | |
| 1448 STD c3,64(r_ptr) | |
| 1449 COPY %r0,c3 | |
| 1450 | |
| 1451 MUL_ADD_C a2L,a2R,b7L,b7R,c1,c2,c3 | |
| 1452 MUL_ADD_C a3L,a3R,b6L,b6R,c1,c2,c3 | |
| 1453 MUL_ADD_C a4L,a4R,b5L,b5R,c1,c2,c3 | |
| 1454 MUL_ADD_C a5L,a5R,b4L,b4R,c1,c2,c3 | |
| 1455 MUL_ADD_C a6L,a6R,b3L,b3R,c1,c2,c3 | |
| 1456 MUL_ADD_C a7L,a7R,b2L,b2R,c1,c2,c3 | |
| 1457 STD c1,72(r_ptr) | |
| 1458 COPY %r0,c1 | |
| 1459 | |
| 1460 MUL_ADD_C a7L,a7R,b3L,b3R,c2,c3,c1 | |
| 1461 MUL_ADD_C a6L,a6R,b4L,b4R,c2,c3,c1 | |
| 1462 MUL_ADD_C a5L,a5R,b5L,b5R,c2,c3,c1 | |
| 1463 MUL_ADD_C a4L,a4R,b6L,b6R,c2,c3,c1 | |
| 1464 MUL_ADD_C a3L,a3R,b7L,b7R,c2,c3,c1 | |
| 1465 STD c2,80(r_ptr) | |
| 1466 COPY %r0,c2 | |
| 1467 | |
| 1468 MUL_ADD_C a4L,a4R,b7L,b7R,c3,c1,c2 | |
| 1469 MUL_ADD_C a5L,a5R,b6L,b6R,c3,c1,c2 | |
| 1470 MUL_ADD_C a6L,a6R,b5L,b5R,c3,c1,c2 | |
| 1471 MUL_ADD_C a7L,a7R,b4L,b4R,c3,c1,c2 | |
| 1472 STD c3,88(r_ptr) | |
| 1473 COPY %r0,c3 | |
| 1474 | |
| 1475 MUL_ADD_C a7L,a7R,b5L,b5R,c1,c2,c3 | |
| 1476 MUL_ADD_C a6L,a6R,b6L,b6R,c1,c2,c3 | |
| 1477 MUL_ADD_C a5L,a5R,b7L,b7R,c1,c2,c3 | |
| 1478 STD c1,96(r_ptr) | |
| 1479 COPY %r0,c1 | |
| 1480 | |
| 1481 MUL_ADD_C a6L,a6R,b7L,b7R,c2,c3,c1 | |
| 1482 MUL_ADD_C a7L,a7R,b6L,b6R,c2,c3,c1 | |
| 1483 STD c2,104(r_ptr) | |
| 1484 COPY %r0,c2 | |
| 1485 | |
| 1486 MUL_ADD_C a7L,a7R,b7L,b7R,c3,c1,c2 | |
| 1487 STD c3,112(r_ptr) | |
| 1488 STD c1,120(r_ptr) | |
| 1489 | |
| 1490 .EXIT | |
| 1491 FLDD -88(%sp),%fr13 | |
| 1492 FLDD -96(%sp),%fr12 | |
| 1493 LDD -104(%sp),%r6 ; restore r6 | |
| 1494 LDD -112(%sp),%r5 ; restore r5 | |
| 1495 LDD -120(%sp),%r4 ; restore r4 | |
| 1496 BVE (%rp) | |
| 1497 LDD,MB -128(%sp),%r3 | |
| 1498 | |
| 1499 .PROCEND | |
| 1500 | |
| 1501 ;----------------------------------------------------------------------------- | |
| 1502 ; | |
| 1503 ;void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b) | |
| 1504 ; arg0 = r_ptr | |
| 1505 ; arg1 = a_ptr | |
| 1506 ; arg2 = b_ptr | |
| 1507 ; | |
| 1508 | |
| 1509 bn_mul_comba4 | |
| 1510 .proc | |
| 1511 .callinfo FRAME=128,ENTRY_GR=%r3,ARGS_SAVED,ORDERING_AWARE | |
| 1512 .EXPORT bn_mul_comba4,ENTRY,PRIV_LEV=3,NO_RELOCATION,LONG_RETURN | |
| 1513 .entry | |
| 1514 .align 64 | |
| 1515 | |
| 1516 STD %r3,0(%sp) ; save r3 | |
| 1517 STD %r4,8(%sp) ; save r4 | |
| 1518 STD %r5,16(%sp) ; save r5 | |
| 1519 STD %r6,24(%sp) ; save r6 | |
| 1520 FSTD %fr12,32(%sp) ; save r6 | |
| 1521 FSTD %fr13,40(%sp) ; save r7 | |
| 1522 | |
| 1523 ; | |
| 1524 ; Zero out carries | |
| 1525 ; | |
| 1526 COPY %r0,c1 | |
| 1527 COPY %r0,c2 | |
| 1528 COPY %r0,c3 | |
| 1529 | |
| 1530 LDO 128(%sp),%sp ; bump stack | |
| 1531 DEPDI,Z 1,31,1,high_one ; Create Value 1 << 32 | |
| 1532 | |
| 1533 ; | |
| 1534 ; Load up all of the values we are going to use | |
| 1535 ; | |
| 1536 FLDD 0(a_ptr),a0 | |
| 1537 FLDD 8(a_ptr),a1 | |
| 1538 FLDD 16(a_ptr),a2 | |
| 1539 FLDD 24(a_ptr),a3 | |
| 1540 | |
| 1541 FLDD 0(b_ptr),b0 | |
| 1542 FLDD 8(b_ptr),b1 | |
| 1543 FLDD 16(b_ptr),b2 | |
| 1544 FLDD 24(b_ptr),b3 | |
| 1545 | |
| 1546 MUL_ADD_C a0L,a0R,b0L,b0R,c1,c2,c3 | |
| 1547 STD c1,0(r_ptr) | |
| 1548 COPY %r0,c1 | |
| 1549 | |
| 1550 MUL_ADD_C a0L,a0R,b1L,b1R,c2,c3,c1 | |
| 1551 MUL_ADD_C a1L,a1R,b0L,b0R,c2,c3,c1 | |
| 1552 STD c2,8(r_ptr) | |
| 1553 COPY %r0,c2 | |
| 1554 | |
| 1555 MUL_ADD_C a2L,a2R,b0L,b0R,c3,c1,c2 | |
| 1556 MUL_ADD_C a1L,a1R,b1L,b1R,c3,c1,c2 | |
| 1557 MUL_ADD_C a0L,a0R,b2L,b2R,c3,c1,c2 | |
| 1558 STD c3,16(r_ptr) | |
| 1559 COPY %r0,c3 | |
| 1560 | |
| 1561 MUL_ADD_C a0L,a0R,b3L,b3R,c1,c2,c3 | |
| 1562 MUL_ADD_C a1L,a1R,b2L,b2R,c1,c2,c3 | |
| 1563 MUL_ADD_C a2L,a2R,b1L,b1R,c1,c2,c3 | |
| 1564 MUL_ADD_C a3L,a3R,b0L,b0R,c1,c2,c3 | |
| 1565 STD c1,24(r_ptr) | |
| 1566 COPY %r0,c1 | |
| 1567 | |
| 1568 MUL_ADD_C a3L,a3R,b1L,b1R,c2,c3,c1 | |
| 1569 MUL_ADD_C a2L,a2R,b2L,b2R,c2,c3,c1 | |
| 1570 MUL_ADD_C a1L,a1R,b3L,b3R,c2,c3,c1 | |
| 1571 STD c2,32(r_ptr) | |
| 1572 COPY %r0,c2 | |
| 1573 | |
| 1574 MUL_ADD_C a2L,a2R,b3L,b3R,c3,c1,c2 | |
| 1575 MUL_ADD_C a3L,a3R,b2L,b2R,c3,c1,c2 | |
| 1576 STD c3,40(r_ptr) | |
| 1577 COPY %r0,c3 | |
| 1578 | |
| 1579 MUL_ADD_C a3L,a3R,b3L,b3R,c1,c2,c3 | |
| 1580 STD c1,48(r_ptr) | |
| 1581 STD c2,56(r_ptr) | |
| 1582 | |
| 1583 .EXIT | |
| 1584 FLDD -88(%sp),%fr13 | |
| 1585 FLDD -96(%sp),%fr12 | |
| 1586 LDD -104(%sp),%r6 ; restore r6 | |
| 1587 LDD -112(%sp),%r5 ; restore r5 | |
| 1588 LDD -120(%sp),%r4 ; restore r4 | |
| 1589 BVE (%rp) | |
| 1590 LDD,MB -128(%sp),%r3 | |
| 1591 | |
| 1592 .PROCEND | |
| 1593 | |
| 1594 | |
| 1595 .SPACE $TEXT$ | |
| 1596 .SUBSPA $CODE$ | |
| 1597 .SPACE $PRIVATE$,SORT=16 | |
| 1598 .IMPORT $global$,DATA | |
| 1599 .SPACE $TEXT$ | |
| 1600 .SUBSPA $CODE$ | |
| 1601 .SUBSPA $LIT$,ACCESS=0x2c | |
| 1602 C$4 | |
| 1603 .ALIGN 8 | |
| 1604 .STRINGZ "Division would overflow (%d)\n" | |
| 1605 .END | |
| 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