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_ULONG 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_AWARE 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 1606
