/linux-4.4.14/arch/m68k/fpsp040/ |
H A D | sto_res.S | 5 | Library functions return result in fp0. If fp0 is not the 6 | users destination register then fp0 is moved to the 7 | correct floating-point destination register. fp0 and fp1 10 | Input: result in fp0,fp1 35 cmpib #3,%d0 |check for fp0/fp1 cases 68 cmpib #3,%d0 |check for fp0/fp1 cases 70 fmovemx %fp0-%fp0,-(%a7) 85 fmovemx %fp0-%fp0,USER_FP3(%a6) 88 fmovemx %fp0-%fp0,USER_FP2(%a6) 91 fmovemx %fp0-%fp0,USER_FP1(%a6) 94 fmovemx %fp0-%fp0,USER_FP0(%a6)
|
H A D | scosh.S | 72 fmoves #0x3F800000,%fp0 75 fadds #0x00800000,%fp0 80 fmovex (%a0),%fp0 | ...LOAD INPUT 91 fabsx %fp0 | ...|X| 95 fmovemx %fp0-%fp0,(%a0) |pass parameter to setox 97 fmuls #0x3F000000,%fp0 | ...(1/2)EXP(|X|) 101 fdivx %fp0,%fp1 | ...1/(2 EXP(|X|)) 104 faddx %fp1,%fp0 112 fabsx %fp0 113 fsubd T1(%pc),%fp0 | ...(|X|-16381LOG2_LEAD) 114 fsubd T2(%pc),%fp0 | ...|X| - 16381 LOG2, ACCURATE 118 fmovemx %fp0-%fp0,(%a0) 122 fmulx TWO16380(%pc),%fp0 128 fmovemx (%a0),%fp0-%fp0
|
H A D | sacos.S | 59 fmovex PIBY2,%fp0 64 fmovex (%a0),%fp0 | ...LOAD INPUT 76 faddx %fp0,%fp1 | ...1+X 77 fnegx %fp0 | ... -X 78 fadds #0x3F800000,%fp0 | ...1-X 79 fdivx %fp1,%fp0 | ...(1-X)/(1+X) 80 fsqrtx %fp0 | ...SQRT((1-X)/(1+X)) 81 fmovemx %fp0-%fp0,(%a0) | ...overwrite input 86 faddx %fp0,%fp0 | ...2 * ATAN( STUFF ) 90 fabsx %fp0 91 fcmps #0x3F800000,%fp0 102 fmovex PI,%fp0 104 fadds #0x00800000,%fp0 |cause an inexact exception to be put 111 fmoves #0x00000000,%fp0
|
H A D | ssinh.S | 76 fmovex (%a0),%fp0 | ...LOAD INPUT 88 fabsx %fp0 | ...Y = |X| 91 fmovemx %fp0-%fp0,(%a0) 97 fmovex %fp0,%fp1 99 fmovex %fp0,-(%sp) 100 fdivx %fp1,%fp0 | ...Z/(1+Z) 104 faddx (%sp)+,%fp0 108 fmuls (%sp)+,%fp0 |last fp inst - possible exceptions set 115 fabsx %fp0 116 fsubd T1(%pc),%fp0 | ...(|X|-16381LOG2_LEAD) 123 fsubd T2(%pc),%fp0 | ...|X| - 16381 LOG2, ACCURATE 127 fmovemx %fp0-%fp0,(%a0) 131 fmulx (%sp)+,%fp0 |possible exception
|
H A D | ssin.S | 160 fmoves #0x3F800000,%fp0 182 fmovex (%a0),%fp0 | ...LOAD INPUT 186 fmovex %fp0,X(%a6) 201 fmovex %fp0,%fp1 216 fsubx (%a1)+,%fp0 | ...X-Y1 218 fsubs (%a1),%fp0 | ...FP0 IS R = (X-Y1)-Y2 239 fmovex %fp0,X(%a6) | ...X IS R 240 fmulx %fp0,%fp0 | ...FP0 IS S 245 fmovex %fp0,%fp1 268 fmulx %fp0,%fp2 | ...S(A2+T(A4+TA6)) 270 fmulx X(%a6),%fp0 | ...R'*S 277 fmulx %fp1,%fp0 | ...SIN(R')-R' 281 faddx X(%a6),%fp0 |last inst - possible exception set 296 fmulx %fp0,%fp0 | ...FP0 IS S 301 fmovex %fp0,%fp1 304 fmovex %fp0,X(%a6) | ...X IS S 334 fmulx %fp2,%fp0 | ...S(B2+T(B4+T(B6+TB8))) 339 faddx %fp1,%fp0 342 fmulx X(%a6),%fp0 345 fadds POSNEG1(%a6),%fp0 |last inst - possible exception set 364 fmovex X(%a6),%fp0 |last inst - possible exception set 369 fmoves #0x3F800000,%fp0 372 fsubs #0x00800000,%fp0 |last inst - possible exception set 394 ftstx %fp0 |test sign of argument 403 faddx FP_SCR2(%a6),%fp0 |high part of reduction is exact 404 fmovex %fp0,%fp1 |save high result in fp1 405 faddx FP_SCR3(%a6),%fp0 |low part of reduction 406 fsubx %fp0,%fp1 |determine low component of result 407 faddx FP_SCR3(%a6),%fp1 |fp0/fp1 are reduced argument. 414 fmovex %fp0,INARG(%a6) | ...+-2**K * F, 1 <= F < 2 443 fmovex %fp0,%fp2 493 fsubx %fp3,%fp0 | ...FP0 is A := R - P 496 fmovex %fp0,%fp3 | ...FP3 A 501 faddx %fp1,%fp0 | ...FP0 is R := A+a 507 fsubx %fp0,%fp3 | ...A-R 536 fmovex (%a0),%fp0 | ...LOAD INPUT 540 fmovex %fp0,X(%a6) 556 fmovex %fp0,%fp1 570 fsubx (%a1)+,%fp0 | ...X-Y1 571 fsubs (%a1),%fp0 | ...FP0 IS R = (X-Y1)-Y2 586 fmovex %fp0,RPRIME(%a6) 587 fmulx %fp0,%fp0 | ...FP0 IS S = R*R 590 fmulx %fp0,%fp1 | ...SA7 593 fmulx %fp0,%fp2 | ...SB8 602 fmulx %fp0,%fp1 | ...S(A6+SA7) 605 fmulx %fp0,%fp2 | ...S(B7+SB8) 614 fmulx %fp0,%fp1 | ...S(A5+S(A6+SA7)) 615 fmulx %fp0,%fp2 | ...S(B6+S(B7+SB8)) 616 fmovex %fp0,SPRIME(%a6) 622 fmulx %fp0,%fp1 | ...S(A4+...) 623 fmulx %fp0,%fp2 | ...S(B5+...) 628 fmulx %fp0,%fp1 | ...S(A3+...) 629 fmulx %fp0,%fp2 | ...S(B4+...) 634 fmulx %fp0,%fp1 | ...S(A2+...) 635 fmulx %fp0,%fp2 | ...S(B3+...) 640 fmulx %fp0,%fp1 | ...S(A1+...) 641 fmulx %fp2,%fp0 | ...S(B2+...) 646 fadds COSB1,%fp0 | ...B1+S(B2...) 647 fmulx SPRIME(%a6),%fp0 | ...S'(B1+S(B2+...)) 655 fadds POSNEG1(%a6),%fp0 | ...SIN(X) 663 fmovex %fp0,RPRIME(%a6) 664 fmulx %fp0,%fp0 | ...FP0 IS S = R*R 667 fmulx %fp0,%fp1 | ...SB8 668 fmovex %fp0,SPRIME(%a6) 669 fmulx %fp0,%fp2 | ...SA7 676 fmulx %fp0,%fp1 | ...S(B7+SB8) 679 fmulx %fp0,%fp2 | ...S(A6+SA7) 684 fmulx %fp0,%fp1 | ...S(B6+S(B7+SB8)) 685 fmulx %fp0,%fp2 | ...S(A5+S(A6+SA7)) 690 fmulx %fp0,%fp1 | ...S(B5+...) 691 fmulx %fp0,%fp2 | ...S(A4+...) 696 fmulx %fp0,%fp1 | ...S(B4+...) 697 fmulx %fp0,%fp2 | ...S(A3+...) 702 fmulx %fp0,%fp1 | ...S(B3+...) 703 fmulx %fp0,%fp2 | ...S(A2+...) 708 fmulx %fp0,%fp1 | ...S(B2+...) 709 fmulx %fp2,%fp0 | ...s(a1+...) 714 fmulx RPRIME(%a6),%fp0 | ...R'S(A1+...) 723 faddx RPRIME(%a6),%fp0 | ...SIN(X) 742 fmovex X(%a6),%fp0
|
H A D | sasin.S | 63 fmovex (%a0),%fp0 | ...LOAD INPUT 75 fsubx %fp0,%fp1 | ...1-X 78 faddx %fp0,%fp2 | ...1+X 82 fdivx %fp1,%fp0 | ...X/SQRT([1-X][1+X]) 83 fmovemx %fp0-%fp0,(%a0) 88 fabsx %fp0 | ...|X| 89 fcmps #0x3F800000,%fp0 94 fmovex PIBY2,%fp0 100 fmuls (%sp)+,%fp0
|
H A D | satanh.S | 78 fabsx (%a0),%fp0 | ...Y = |X| 79 fmovex %fp0,%fp1 81 faddx %fp0,%fp0 | ...2Y 83 fdivx %fp1,%fp0 | ...2Y/(1-Y) 89 fmovemx %fp0-%fp0,(%a0) | ...overwrite input 94 fmuls (%sp)+,%fp0 98 fabsx (%a0),%fp0 | ...|X| 99 fcmps #0x3F800000,%fp0
|
H A D | stanh.S | 84 fmovex (%a0),%fp0 | ...LOAD INPUT 86 fmovex %fp0,X(%a6) 103 fmovex X(%a6),%fp0 | ...FP0 IS Y = 2|X| 107 fmovemx %fp0-%fp0,(%a0) 111 fmovex %fp0,%fp1 118 fdivx V(%a6),%fp0 139 fmovex X(%a6),%fp0 | ...Y = 2|X| 143 fmovemx %fp0-%fp0,(%a0) 147 fadds #0x3F800000,%fp0 | ...EXP(Y)+1 151 fdivx %fp0,%fp1 | ...-SIGN(X)2 / [EXP(Y)+1 ] 155 fmoves %d0,%fp0 | ...SGN IN SGL FMT 158 faddx %fp1,%fp0 166 fmovex X(%a6),%fp0 |last inst - possible exception set 175 fmoves %d0,%fp0 180 fadds %d0,%fp0
|
H A D | setox.S | 16 | exp(X) or exp(X)-1 returned in floating-point register fp0. 455 fmoves #0x3F800000,%fp0 457 fadds (%sp)+,%fp0 481 fmovex (%a0),%fp0 | ...load input from (a0) 483 fmovex %fp0,%fp1 484 fmuls #0x42B8AA3B,%fp0 | ...64/log2 * X 487 fmovel %fp0,%d0 | ...N = int( X * 64/log2 ) 489 fmovel %d0,%fp0 | ...convert to floating-format 502 |--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 504 fmovex %fp0,%fp2 505 fmuls #0xBC317218,%fp0 | ...N * L1, L1 = lead(-log2/64) 507 faddx %fp1,%fp0 | ...X + N*L1 508 faddx %fp2,%fp0 | ...fp0 is R, reduced arg. 517 fmovex %fp0,%fp1 539 fmulx %fp0,%fp3 | ...fp3 IS R*S*(A2+S*A4) 542 faddx %fp3,%fp0 | ...fp0 IS R+R*S*(A2+S*A4), 546 faddx %fp2,%fp0 | ...fp0 is EXP(R) - 1 553 fmulx %fp1,%fp0 | ...2^(J/64)*(Exp(R)-1) 555 fadds (%a1),%fp0 | ...accurate 2^(J/64) 557 faddx %fp1,%fp0 | ...2^(J/64) + 2^(J/64)*... 564 fmulx ADJSCALE(%a6),%fp0 567 fmulx SCALE(%a6),%fp0 | ...multiply 2^(M) 572 fmovemx (%a0),%fp0-%fp0 | ...in case X is denormalized 574 fadds #0x3F800000,%fp0 | ...1+X in user mode 582 fmovex (%a0),%fp0 | ...load input from (a0) 584 fmovex %fp0,%fp1 585 fmuls #0x42B8AA3B,%fp0 | ...64/log2 * X 588 fmovel %fp0,%d0 | ...N = int( X * 64/log2 ) 590 fmovel %d0,%fp0 | ...convert to floating-format 648 fmovex (%a0),%fp0 | ...load input from (a0) 650 fmovex %fp0,%fp1 651 fmuls #0x42B8AA3B,%fp0 | ...64/log2 * X 654 fmovel %fp0,%d0 | ...N = int( X * 64/log2 ) 656 fmovel %d0,%fp0 | ...convert to floating-format 668 |--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 670 fmovex %fp0,%fp2 671 fmuls #0xBC317218,%fp0 | ...N * L1, L1 = lead(-log2/64) 673 faddx %fp1,%fp0 | ...X + N*L1 674 faddx %fp2,%fp0 | ...fp0 is R, reduced arg. 684 fmovex %fp0,%fp1 718 fmulx %fp0,%fp2 | ...fp2 IS R*S*(A2+S*(A4+S*A6)) 719 faddx %fp1,%fp0 | ...fp0 IS R+S*(A1+S*(A3+S*A5)) 722 faddx %fp2,%fp0 | ...fp0 IS EXP(R)-1 729 fmulx (%a1),%fp0 | ...2^(J/64)*(Exp(R)-1) 739 faddx %fp1,%fp0 | ...p+(t+OnebySc), fp1 released 740 faddx (%a1),%fp0 | ...T+(p+(t+OnebySc)) 748 fadds 12(%a1),%fp0 | ...p+t 749 faddx (%a1),%fp0 | ...T+(p+t) 750 faddx ONEBYSC(%a6),%fp0 | ...OnebySc + (T+(p+t)) 755 fadds (%a1),%fp0 | ...fp0 is p+t 757 faddx %fp1,%fp0 | ...(T+OnebySc)+(p+t) 762 fmulx SC(%a6),%fp0 779 fmovex (%a0),%fp0 781 faddx SC(%a6),%fp0 787 fmovex (%a0),%fp0 788 fmuld TWO140,%fp0 792 faddx SC(%a6),%fp0 794 fmuld TWON140,%fp0 800 fmovex (%a0),%fp0 | ...fp0 is X 801 fmulx %fp0,%fp0 | ...fp0 is S := X*X 804 fmulx %fp0,%fp1 | ...fp1 is S*B12 808 fmulx %fp0,%fp2 | ...fp2 is S*B11 809 fmulx %fp0,%fp1 | ...fp1 is S*(B10 + ... 814 fmulx %fp0,%fp2 | ...fp2 is S*(B9+... 815 fmulx %fp0,%fp1 | ...fp1 is S*(B8+... 820 fmulx %fp0,%fp2 | ...fp2 is S*(B7+... 821 fmulx %fp0,%fp1 | ...fp1 is S*(B6+... 826 fmulx %fp0,%fp2 | ...fp2 is S*(B5+... 827 fmulx %fp0,%fp1 | ...fp1 is S*(B4+... 832 fmulx %fp0,%fp2 | ...fp2 is S*(B3+... 833 fmulx %fp0,%fp1 | ...fp1 is S*(B2+... 835 fmulx %fp0,%fp2 | ...fp2 is S*S*(B3+...) 838 fmuls #0x3F000000,%fp0 | ...fp0 is S*B1 844 faddx %fp1,%fp0 | ...fp0 is S*B1+Q 848 faddx (%a0),%fp0 858 fmoves #0xBF800000,%fp0 | ...fp0 is -1 860 fadds #0x00800000,%fp0 | ...-1 + 2^(-126)
|
H A D | stan.S | 171 fmovex (%a0),%fp0 | ...LOAD INPUT 189 fmovex %fp0,%fp1 201 fsubx (%a1)+,%fp0 | ...X-Y1 204 fsubs (%a1),%fp0 | ...FP0 IS R = (X-Y1)-Y2 214 fmovex %fp0,%fp1 236 fmulx %fp0,%fp2 | ...RS(P1+S(P2+SP3)) 241 faddx %fp2,%fp0 | ...R+RS(P1+S(P2+SP3)) 247 fdivx %fp1,%fp0 |last inst - possible exception set 252 fmovex %fp0,%fp1 253 fmulx %fp0,%fp0 | ...S = R*R 258 fmulx %fp0,%fp3 | ...SQ4 259 fmulx %fp0,%fp2 | ...SP3 264 fmulx %fp0,%fp3 | ...S(Q3+SQ4) 265 fmulx %fp0,%fp2 | ...S(P2+SP3) 270 fmulx %fp0,%fp3 | ...S(Q2+S(Q3+SQ4)) 271 fmulx %fp0,%fp2 | ...S(P1+S(P2+SP3)) 276 fmulx %fp3,%fp0 | ...S(Q1+S(Q2+S(Q3+SQ4))) 280 fadds #0x3F800000,%fp0 | ...1+S(Q1+...) 287 fdivx (%sp)+,%fp0 |last inst - possible exception set 299 fmovex %fp0,-(%sp) 301 fmovex (%sp)+,%fp0 |last inst - possible exception set 325 ftstx %fp0 |test sign of argument 334 faddx FP_SCR2(%a6),%fp0 |high part of reduction is exact 335 fmovex %fp0,%fp1 |save high result in fp1 336 faddx FP_SCR3(%a6),%fp0 |low part of reduction 337 fsubx %fp0,%fp1 |determine low component of result 338 faddx FP_SCR3(%a6),%fp1 |fp0/fp1 are reduced argument. 345 fmovex %fp0,INARG(%a6) | ...+-2**K * F, 1 <= F < 2 374 fmovex %fp0,%fp2 424 fsubx %fp3,%fp0 | ...FP0 is A := R - P 427 fmovex %fp0,%fp3 | ...FP3 A 432 faddx %fp1,%fp0 | ...FP0 is R := A+a 438 fsubx %fp0,%fp3 | ...A-R
|
H A D | sgetem.S | 7 | precision number in fp0. sGETEXPD handles denormalized 12 | extended precision number and returned in fp0. The 19 | Output: The functions return exp(X) or man(X) in fp0. 21 | Modified: fp0. 52 fmovew %d0,%fp0 |move the exp to fp0 61 fmovew %d0,%fp0 |move the exp to fp0 85 fmovex (%a0),%fp0 |put new value back in fp0
|
H A D | slogn.S | 287 fmovex X(%a6),%fp0 310 fmovex X(%a6),%fp0 320 fmovex (%a0),%fp0 | ...LOAD INPUT 371 fmovex X(%a6),%fp0 374 fsubx F(%a6),%fp0 | ...Y-F 381 fmulx (%a0),%fp0 | ...FP0 IS U = (Y-F)/F 383 fmovex %fp0,%fp2 410 fmulx %fp0,%fp1 | ...U*V*(A2+V*(A4+V*A6)) 411 faddx %fp2,%fp0 | ...U+V*(A1+V*(A3+V*A5)), FP2 RELEASED 415 faddx %fp1,%fp0 | ...FP0 IS LOG(F) + LOG(1+U) 418 faddx KLOG2(%a6),%fp0 | ...FINAL ADD 424 fmovex %fp0,%fp1 426 fadds one,%fp0 | ...FP0 IS X+1 433 fdivx %fp0,%fp1 | ...FP1 IS U 439 fmovex %fp1,%fp0 440 fmulx %fp0,%fp0 | ...FP0 IS V 442 fmovex %fp0,%fp1 456 fmulx %fp0,%fp2 | ...V*(B2+W*B4) 459 fmulx SAVEU(%a6),%fp0 | ...FP0 IS U*V 464 fmulx %fp1,%fp0 | ...U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] ) 467 faddx SAVEU(%a6),%fp0 486 fmovex (%a0),%fp0 | ...LOAD INPUT 487 fabsx %fp0 |test magnitude 488 fcmpx LTHOLD,%fp0 |compare with min threshold 492 fmovex (%a0),%fp0 |return signed argument 496 fmovex (%a0),%fp0 | ...LOAD INPUT 498 fmovex %fp0,%fp1 | ...FP1 IS INPUT Z 499 fadds one,%fp0 | ...X := ROUND(1+Z) 500 fmovex %fp0,X(%a6) 520 fadds one,%fp0 | ...FP0 IS 1+X 541 fmoves TWO,%fp0 544 fsubx F(%a6),%fp0 | ...2-F 552 faddx %fp1,%fp0 | ...FP0 IS Y-F = (2-F)+2Z 559 fmoves one,%fp0 562 fsubx F(%a6),%fp0 | ...1-F 568 faddx %fp1,%fp0 | ...FP0 IS Y-F 580 fmoves negone,%fp0 586 fmoves zero,%fp0
|
H A D | stwotox.S | 200 fmoves #0x3F800000,%fp0 | ...RETURN 1 + X 203 fadds %d0,%fp0 209 fmovemx (%a0),%fp0-%fp0 | ...LOAD INPUT, do not set cc's 213 fmovex %fp0,X(%a6) 229 fmovex %fp0,%fp1 260 fsubx %fp1,%fp0 | ...X - (1/64)*INT(64 X) 267 fmulx LOG2,%fp0 | ...FP0 IS R 281 fadds #0x3F800000,%fp0 | ...RETURN 1 + X 304 fmoves #0x3F800000,%fp0 | ...RETURN 1 + X 307 fadds %d0,%fp0 313 fmovemx (%a0),%fp0-%fp0 | ...LOAD INPUT, do not set cc's 317 fmovex %fp0,X(%a6) 332 fmovex %fp0,%fp1 366 fsubx %fp1,%fp0 | ...X - N L_LEAD 369 fsubx %fp2,%fp0 | ...X - N L_TRAIL 376 fmulx LOG10,%fp0 | ...FP0 IS R 387 fmovex %fp0,%fp1 403 fmulx %fp0,%fp3 | ...FP3 IS R*S*(A2+S*A4) 406 faddx %fp3,%fp0 | ...FP0 IS R+R*S*(A2+S*A4) 408 faddx %fp2,%fp0 | ...FP0 IS EXP(R) - 1 414 fmulx FACT1(%a6),%fp0 415 faddx FACT2(%a6),%fp0 416 faddx FACT1(%a6),%fp0 422 fmulx ADJFACT(%a6),%fp0 | ...FINAL ADJUSTMENT
|
H A D | satan.S | 240 fmovex (%a0),%fp0 | ...LOAD INPUT 244 fmovex %fp0,X(%a6) 285 fmovex %fp0,%fp1 | ...FP1 IS X 287 fsubx X(%a6),%fp0 | ...FP0 IS X-F 289 fdivx %fp1,%fp0 | ...FP0 IS U = (X-F)/(1+X*F) 325 fmovex %fp0,%fp1 330 fmulx %fp0,%fp1 | ...U*V 335 faddx %fp1,%fp0 | ...ATAN(U), FP1 RELEASED 337 faddx ATANF(%a6),%fp0 | ...ATAN(X) 356 fmulx %fp0,%fp0 | ...FP0 IS Y = X*X 361 fmovex %fp0,%fp1 379 fmulx %fp0,%fp2 | ...Y*(B2+Z*(B4+Z*B6)) 380 fmulx X(%a6),%fp0 | ...X*Y 385 fmulx %fp1,%fp0 | ...X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) 388 faddx X(%a6),%fp0 397 fmovex X(%a6),%fp0 |last inst - possible exception set 413 fdivx %fp0,%fp1 | ...FP1 IS -1/X 418 fmovex %fp1,%fp0 | ...FP0 IS X' 419 fmulx %fp0,%fp0 | ...FP0 IS Y = X'*X' 422 fmovex %fp0,%fp1 435 fmulx %fp0,%fp2 | ...Y*(C2+Z*C4) 438 fmulx X(%a6),%fp0 | ...X'*Y 443 fmulx %fp1,%fp0 | ...X'*Y*([B1+Z*(B3+Z*B5)] 445 faddx X(%a6),%fp0 453 faddx NPIBY2,%fp0 457 faddx PPIBY2,%fp0 466 fmovex NPIBY2,%fp0 468 fsubx NTINY,%fp0 472 fmovex PPIBY2,%fp0 474 fsubx PTINY,%fp0
|
H A D | x_bsun.S | 33 fmovemx %fp0-%fp3,USER_FP0(%a6) 40 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | bindec.S | 83 | is in fp0. 123 | fp0: scratch 166 fmovemx %fp0-%fp2,-(%a7) 234 | fp0: x/float(ILOG) 249 fmovex FP_SCR2(%a6),%fp0 |now fp0 has 1.f 251 faddw %d0,%fp0 |add in exp 252 fsubs FONE,%fp0 |subtract off 1.0 254 fmulx LOG2UP1,%fp0 |if neg, mul by LOG2UP1 255 fmovel %fp0,%d6 |put ILOG in d6 as a lword 258 fmulx LOG2,%fp0 |if pos, mul by LOG2 259 fmovel %fp0,%d6 |put ILOG in d6 as a lword 297 | fp0: float(ILOG)/Unchanged 369 | fp0: float(ILOG)/Unchanged 474 | fp0: float(ILOG)/X adjusted for SCALE (Y) 483 fmovex (%a0),%fp0 |load X from memory 484 fabsx %fp0 |use abs(X) 487 fdivx %fp1,%fp0 |calculate X / SCALE -> Y to fp0 507 fmulx 36(%a1),%fp0 |multiply fp0 by 10^8 508 fmulx 48(%a1),%fp0 |multiply fp0 by 10^16 513 fmulx 36(%a1),%fp0 |multiply fp0 by 10^8 514 fmulx 48(%a1),%fp0 |multiply fp0 by 10^16 516 fmulx %fp1,%fp0 |calculate X * SCALE -> Y to fp0 535 | fp0: Y/Y with lsb adjusted 541 fmovex %fp0,FP_SCR2(%a6) |move Y to memory 546 fmovex FP_SCR2(%a6),%fp0 |write adjusted Y back to fpu 562 | The FPSP routine sintd0 is used. The output is in fp0. 577 | fp0: Y/YINT 590 fmovex %fp0,(%a0) |move Y to memory at FP_SCR2(a6) 596 bsr sintdo |sint routine returns int in fp0 629 | fp0: int portion of Y/abs(YINT) adjusted 662 fabsx %fp0 |take abs of YINT 668 fabsx %fp0 |take abs of YINT 669 fcmpx %fp2,%fp0 |compare abs(YINT) with 10^(LEN-1) 678 fcmpx %fp2,%fp0 |compare abs(YINT) with 10^LEN 681 fdivs FTEN,%fp0 |if equal, divide by 10 707 fabsx %fp0 |get abs(YINT) 708 fcmpx %fp2,%fp0 |check if abs(YINT) = 10^LEN 710 fdivs FTEN,%fp0 |divide abs(YINT) by 10 739 | fp0: int portion of Y/abs(YINT) adjusted 749 fdivx %fp2,%fp0 |divide abs(YINT) by 10^LEN 751 fmovex %fp0,(%a0) |move abs(YINT)/10^LEN to memory 811 | fp0: abs(YINT) adjusted/float(ILOG) 822 ftstx %fp0 |test for zero 824 fmovel %d6,%fp0 |float ILOG 825 fabsx %fp0 |get abs of ILOG 830 fmoves F4933,%fp0 |force exponent to 4933 833 fmovel %d6,%fp0 |float ILOG 834 fabsx %fp0 |get abs of ILOG 837 ftstx %fp0 |test for zero 839 fmoves FONE,%fp0 |force exponent to 1 842 fmovel %d6,%fp0 |float ILOG 843 fabsx %fp0 |get abs of ILOG 845 fdivx 24(%a1),%fp0 |compute ILOG/10^4 846 fmovex %fp0,FP_SCR2(%a6) |store fp0 in memory 891 | fp0: float(ILOG)/Unchanged 915 fmovemx (%a7)+,%fp0-%fp2
|
H A D | scale.S | 15 | Output: The function returns scale(X,Y) to fp0. 17 | Modifies: fp0. 77 fmovex FPTEMP(%a6),%fp0 |simply return dest 86 fmovex ETEMP(%a6),%fp0 |move in src for int 88 fmovel %fp0,%d0 |int src to d0 110 fmovex FPTEMP(%a6),%fp0 |write result to fp0 138 fmovex FPTEMP(%a6),%fp0 |write result to fp0 157 fmovex FPTEMP(%a6),%fp0 |write result to fp0 227 fmovex FPTEMP(%a6),%fp0 |use fmove to set cc's 286 fmoves #0x80000000,%fp0 292 fmoves #0x00000000,%fp0 328 fmovex FPTEMP(%a6),%fp0
|
H A D | do_func.S | 18 | Called functions return their result in fp0. Sincos returns 19 | sin(x) in fp0 and cos(x) in fp1. 98 | These routines load forced values into fp0. They are called 101 | Load a signed zero to fp0 and set inex2/ainex 113 | Load a signed zero to fp0; do not set inex2/ainex 121 | Load a signed infinity to fp0; do not set inex2/ainex 129 | Load a signed one to fp0; do not set inex2/ainex 137 | Load a signed pi/2 to fp0; do not set inex2/ainex 166 fmovemx (%a0),%fp0-%fp0 167 fcmpb #-1,%fp0 196 fmovex PZERO,%fp0 218 fmovex PZERO,%fp0 240 fmovex PZERO,%fp0 327 fmovex FPTEMP(%a6),%fp0 |return dest to fp0 407 fmovex FPTEMP(%a6),%fp0 |return dest to fp0 475 fmovex MZERO,%fp0 478 fmovex PZERO,%fp0 487 fmovex QNAN,%fp0 |load NAN 507 fmovex PPIBY2,%fp0 |load +pi/2 513 fmovex MPIBY2,%fp0 |load -pi/2 520 fmovex PINF,%fp0 |load +inf 527 fmovex MINF,%fp0 |load -inf 534 fmovex PONE,%fp0 |load +1 540 fmovex MONE,%fp0 |load -1 547 fmovex PZERO,%fp0 |load +0 554 fmovex MZERO,%fp0 |load -0
|
H A D | slog2.S | 14 | register fp0. 124 fmulx INV_L10,%fp0 137 fmulx INV_L10,%fp0 151 fmulx INV_L2,%fp0 173 fmovel %d0,%fp0 181 fmulx INV_L2,%fp0
|
H A D | decbin.S | 172 | 1. Calculate absolute value of mantissa in fp0 by mul and add. 186 | (*) fp0: mantissa accumulator 192 fmoves FZERO,%fp0 |accumulator 200 faddb %d0,%fp0 |add digit to sum in fp0 210 fmuls FTEN,%fp0 |fp0 = fp0 * 10 212 faddb %d0,%fp0 |fp0 = fp0 + digit 228 | Check the sign of the mant and make the value in fp0 the same sign. 233 fnegx %fp0 |if set, negate fp0 337 fmulx %fp1,%fp0 |mul mantissa by 10**(no_bits_shifted) 385 fdivx %fp1,%fp0 |div mantissa by 10**(no_bits_shifted) 471 | Check the sign of the adjusted exp and make the value in fp0 the 472 | same sign. If the exp was pos then multiply fp1*fp0; 473 | else divide fp0/fp1. 478 | (*) fp0: mantissa accumulator 485 fdivx %fp1,%fp0 |exp is negative, so divide mant by exp 488 fmulx %fp1,%fp0 |exp is positive, so multiply by exp 491 | Clean up and return with result in fp0.
|
H A D | kernel_ex.S | 50 | store properly signed inf (use sign of etemp) into fp0 83 fmovemx mns_inf,%fp0-%fp0 |load -inf 87 fmovemx pls_inf,%fp0-%fp0 |load +inf 107 | nan bit; Store default NAN into fp0 121 fmovemx nan,%fp0-%fp0 |load default nan 175 fmovemx (%a0),%fp0-%fp0 |store result in fp0 249 fmovemx ETEMP(%a6),%fp0-%fp0 |move the result to fp0 294 fmovex FPTEMP(%a6),%fp0 |return the non-signalling nan 320 fmovex FPTEMP(%a6),%fp0 |load non-sign. nan 339 fmovex ETEMP(%a6),%fp0 |return the non-signalling nan 355 fmovex ETEMP(%a6),%fp0 |load non-sign. nan 431 fmovemx (%a0),%fp0-%fp0 |store result in fp0
|
H A D | sint.S | 21 | Output: The function returns int(X) or intrz(X) in fp0. 23 | Modifies: fp0. 37 | 4. Normalize the rounded result; store in fp0. 123 | Output: fp0 has the result 201 fmovex LOCAL_EX(%a0),%fp0 |if exp > 63 229 | normalize the rounded result and store value in fp0 242 fmovex LOCAL_EX(%a0),%fp0 |move result to fp0
|
H A D | smovecr.S | 12 | Modified: fp0. 61 fmoves FZERO,%fp0 136 fmovemx (%a0,%d0),%fp0-%fp0 |return result in fp0 158 fmovemx (%a0),%fp0-%fp0
|
H A D | srem_mod.S | 308 fmovex R(%a6),%fp0 | ...no exception 320 fmovex R(%a6),%fp0 350 fsubx Y(%a6),%fp0 | ...no exceptions 359 fnegx %fp0 382 fmulx Scale(%pc),%fp0 | ...may cause underflow 387 fmovex %fp0,%fp0 |capture exceptions & round 403 fmoves #0x00000000,%fp0
|
H A D | x_ovfl.S | 61 fmovemx %fp0-%fp3,USER_FP0(%a6) 86 fmovemx USER_FP0(%a6),%fp0-%fp3 117 fmovemx USER_FP0(%a6),%fp0-%fp3 137 fmovemx USER_FP0(%a6),%fp0-%fp3 144 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | x_unfl.S | 49 fmovemx %fp0-%fp3,USER_FP0(%a6) 74 fmovemx USER_FP0(%a6),%fp0-%fp3 109 fmovemx USER_FP0(%a6),%fp0-%fp3 128 fmovemx USER_FP0(%a6),%fp0-%fp3 135 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | x_snan.S | 46 fmovemx %fp0-%fp3,USER_FP0(%a6) 73 fmovemx USER_FP0(%a6),%fp0-%fp3 106 fmovemx USER_FP0(%a6),%fp0-%fp3 134 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | x_store.S | 52 | if fp0-fp3 is being modified, we must put a copy 54 | handlers restore fp0-fp3 from there. 58 fmovemx %fp0-%fp0,USER_FP0(%a6)
|
H A D | res_func.S | 851 fmovex ETEMP(%a6),%fp0 852 faddx FPTEMP(%a6),%fp0 856 fmovex %fp0,WBTEMP(%a6) |write result to memory 879 fmovex ETEMP(%a6),%fp0 880 faddx FPTEMP(%a6),%fp0 884 fmovex %fp0,WBTEMP(%a6) |write result to memory 1026 fmovex FPTEMP(%a6),%fp0 1027 fsubx ETEMP(%a6),%fp0 1031 fmovex %fp0,WBTEMP(%a6) |write result to memory 1054 fmovex FPTEMP(%a6),%fp0 1055 fsubx ETEMP(%a6),%fp0 1059 fmovex %fp0,WBTEMP(%a6) |write result to memory 1292 bles frc0123 |check if dest is fp0-fp3 1379 bles fp0123 |check if dest is fp0-fp3 1495 fmovemx ETEMP(%a6),%fp0-%fp0 1496 fcmpd #0x41dfffffffc00000,%fp0 1499 fcmpd #0xc1e0000000000000,%fp0 1508 fmovel %fp0,L_SCR1(%a6) |let the 040 perform conversion 1517 fcmpd #0x41dfffffffe00000,%fp0 1525 fcmpd #0xc1e0000000100000,%fp0 1540 fmovemx ETEMP(%a6),%fp0-%fp0 1541 fcmps #0x46fffe00,%fp0 1544 fcmps #0xc7000000,%fp0 1554 fmovew %fp0,L_SCR1(%a6) |let the 040 perform conversion 1562 fcmps #0x46ffff00,%fp0 1570 fcmps #0xc7000080,%fp0 1585 fmovemx ETEMP(%a6),%fp0-%fp0 1586 fcmps #0x42fe0000,%fp0 1589 fcmps #0xc3000000,%fp0 1599 fmoveb %fp0,L_SCR1(%a6) |let the 040 perform conversion 1607 fcmps #0x42ff0000,%fp0 1615 fcmps #0xc3008000,%fp0 1650 fmovemx %fp0-%fp0,FPTEMP(%a6) |FPTEMP must contain the extended
|
H A D | x_unimp.S | 47 fmovemx %fp0-%fp3,USER_FP0(%a6)
|
H A D | x_unsupp.S | 46 fmovemx %fp0-%fp3,USER_FP0(%a6)
|
H A D | x_operr.S | 68 fmovemx %fp0-%fp3,USER_FP0(%a6) 102 fmovemx USER_FP0(%a6),%fp0-%fp3 313 fmovemx USER_FP0(%a6),%fp0-%fp3 339 fmovemx USER_FP0(%a6),%fp0-%fp3 350 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | get_op.S | 488 | fp0 - contains packed string converted to extended precision 489 | ETEMP - same as fp0 535 fmovemx %fp0-%fp1,-(%a7) |save fp0 - decbin returns in it 537 fmovex %fp0,ETEMP(%a6) |put the unpacked sop in the fsave stack 538 fmovemx (%a7)+,%fp0-%fp1 604 fmovemx %fp0-%fp1,-(%a7) |save fp0 ,fp1 - decbin returns in fp0 606 fmovex %fp0,ETEMP(%a6) 608 fmovemx (%a7)+,%fp0-%fp1
|
H A D | bugfix.S | 281 | xu if it is to fp0 - fp3 and write that value to the USER_FPn 299 fmovemx %fp0-%fp0,USER_FP0(%a6) 407 | xu if it is to fp0 - fp3 and write that value to the USER_FPn 425 fmovemx %fp0-%fp0,USER_FP0(%a6)
|
H A D | fpsp.h | 21 | fmovem.x fp0-fp3,USER_FP0(a6) 51 | fmovem.x USER_FP0(a6),fp0-fp3 69 | The registers d0, d1, a0, a1 and fp0-fp3 are always saved and
|
H A D | gen_except.S | 95 | Frame is an unimp frame possible resulting from an fmove <ea>,fp0 232 fmovemx USER_FP0(%a6),%fp0-%fp3 325 | by doing an fmove <ea>,fp0. The exception operand, in 367 fmovemx USER_FP0(%a6),%fp0-%fp3
|
H A D | binstr.S | 134 | Clean up and return with result in fp0.
|
/linux-4.4.14/scripts/ |
H A D | conmakehash.c | 86 int fp0, fp1, un0, un1; main() local 142 fp0 = strtol(p, &p1, 0); main() 166 if ( fp0 < 0 || fp0 >= fontlen ) main() 170 tblname, fp0); main() 173 if ( fp1 && (fp1 < fp0 || fp1 >= fontlen) ) main() 189 for (i=fp0; i<=fp1; i++) main() 211 tblname, fp0, fp1); main() 214 if (un1 - un0 != fp1 - fp0) main() 218 tblname, un0, un1, fp0, fp1); main() 221 for(i=fp0; i<=fp1; i++) main() 222 addpair(i,un0-fp0+i); main() 230 addpair(fp0, un0); main() 274 fp0 = 0; main() 278 while ( nent >= unicount[fp0] ) main() 280 fp0++; main() 283 printf("0x%04x", unitable[fp0][nent++]); main()
|
/linux-4.4.14/arch/m68k/ifpsp060/src/ |
H A D | fplsp.S | 307 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0 567 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 574 fmov.s 0x8(%a6),%fp0 # load sgl input 575 fmov.x %fp0,FP_SRC(%a6) 624 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 631 fmov.d 0x8(%a6),%fp0 # load dbl input 632 fmov.x %fp0,FP_SRC(%a6) 682 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 744 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 751 fmov.s 0x8(%a6),%fp0 # load sgl input 752 fmov.x %fp0,FP_SRC(%a6) 801 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 808 fmov.d 0x8(%a6),%fp0 # load dbl input 809 fmov.x %fp0,FP_SRC(%a6) 859 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 921 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 928 fmov.s 0x8(%a6),%fp0 # load sgl input 929 fmov.x %fp0,FP_SRC(%a6) 978 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 985 fmov.d 0x8(%a6),%fp0 # load dbl input 986 fmov.x %fp0,FP_SRC(%a6) 1036 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1098 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1105 fmov.s 0x8(%a6),%fp0 # load sgl input 1106 fmov.x %fp0,FP_SRC(%a6) 1155 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1162 fmov.d 0x8(%a6),%fp0 # load dbl input 1163 fmov.x %fp0,FP_SRC(%a6) 1213 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1275 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1282 fmov.s 0x8(%a6),%fp0 # load sgl input 1283 fmov.x %fp0,FP_SRC(%a6) 1332 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1339 fmov.d 0x8(%a6),%fp0 # load dbl input 1340 fmov.x %fp0,FP_SRC(%a6) 1390 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1452 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1459 fmov.s 0x8(%a6),%fp0 # load sgl input 1460 fmov.x %fp0,FP_SRC(%a6) 1509 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1516 fmov.d 0x8(%a6),%fp0 # load dbl input 1517 fmov.x %fp0,FP_SRC(%a6) 1567 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1629 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1636 fmov.s 0x8(%a6),%fp0 # load sgl input 1637 fmov.x %fp0,FP_SRC(%a6) 1686 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1693 fmov.d 0x8(%a6),%fp0 # load dbl input 1694 fmov.x %fp0,FP_SRC(%a6) 1744 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1806 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1813 fmov.s 0x8(%a6),%fp0 # load sgl input 1814 fmov.x %fp0,FP_SRC(%a6) 1863 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1870 fmov.d 0x8(%a6),%fp0 # load dbl input 1871 fmov.x %fp0,FP_SRC(%a6) 1921 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1983 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1990 fmov.s 0x8(%a6),%fp0 # load sgl input 1991 fmov.x %fp0,FP_SRC(%a6) 2040 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2047 fmov.d 0x8(%a6),%fp0 # load dbl input 2048 fmov.x %fp0,FP_SRC(%a6) 2098 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2160 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2167 fmov.s 0x8(%a6),%fp0 # load sgl input 2168 fmov.x %fp0,FP_SRC(%a6) 2217 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2224 fmov.d 0x8(%a6),%fp0 # load dbl input 2225 fmov.x %fp0,FP_SRC(%a6) 2275 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2337 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2344 fmov.s 0x8(%a6),%fp0 # load sgl input 2345 fmov.x %fp0,FP_SRC(%a6) 2394 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2401 fmov.d 0x8(%a6),%fp0 # load dbl input 2402 fmov.x %fp0,FP_SRC(%a6) 2452 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2514 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2521 fmov.s 0x8(%a6),%fp0 # load sgl input 2522 fmov.x %fp0,FP_SRC(%a6) 2571 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2578 fmov.d 0x8(%a6),%fp0 # load dbl input 2579 fmov.x %fp0,FP_SRC(%a6) 2629 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2691 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2698 fmov.s 0x8(%a6),%fp0 # load sgl input 2699 fmov.x %fp0,FP_SRC(%a6) 2748 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2755 fmov.d 0x8(%a6),%fp0 # load dbl input 2756 fmov.x %fp0,FP_SRC(%a6) 2806 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2868 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2875 fmov.s 0x8(%a6),%fp0 # load sgl input 2876 fmov.x %fp0,FP_SRC(%a6) 2925 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2932 fmov.d 0x8(%a6),%fp0 # load dbl input 2933 fmov.x %fp0,FP_SRC(%a6) 2983 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3045 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3052 fmov.s 0x8(%a6),%fp0 # load sgl input 3053 fmov.x %fp0,FP_SRC(%a6) 3102 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3109 fmov.d 0x8(%a6),%fp0 # load dbl input 3110 fmov.x %fp0,FP_SRC(%a6) 3160 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3222 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3229 fmov.s 0x8(%a6),%fp0 # load sgl input 3230 fmov.x %fp0,FP_SRC(%a6) 3279 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3286 fmov.d 0x8(%a6),%fp0 # load dbl input 3287 fmov.x %fp0,FP_SRC(%a6) 3337 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3399 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3406 fmov.s 0x8(%a6),%fp0 # load sgl input 3407 fmov.x %fp0,FP_SRC(%a6) 3456 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3463 fmov.d 0x8(%a6),%fp0 # load dbl input 3464 fmov.x %fp0,FP_SRC(%a6) 3514 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3576 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3583 fmov.s 0x8(%a6),%fp0 # load sgl input 3584 fmov.x %fp0,FP_SRC(%a6) 3633 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3640 fmov.d 0x8(%a6),%fp0 # load dbl input 3641 fmov.x %fp0,FP_SRC(%a6) 3691 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3753 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3760 fmov.s 0x8(%a6),%fp0 # load sgl input 3761 fmov.x %fp0,FP_SRC(%a6) 3810 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3817 fmov.d 0x8(%a6),%fp0 # load dbl input 3818 fmov.x %fp0,FP_SRC(%a6) 3868 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3930 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3937 fmov.s 0x8(%a6),%fp0 # load sgl input 3938 fmov.x %fp0,FP_SRC(%a6) 3987 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3994 fmov.d 0x8(%a6),%fp0 # load dbl input 3995 fmov.x %fp0,FP_SRC(%a6) 4045 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4107 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4114 fmov.s 0x8(%a6),%fp0 # load sgl input 4115 fmov.x %fp0,FP_SRC(%a6) 4154 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4155 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4156 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4166 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4173 fmov.d 0x8(%a6),%fp0 # load dbl input 4174 fmov.x %fp0,FP_SRC(%a6) 4214 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4215 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4216 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4226 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4274 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4275 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4276 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4290 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4297 fmov.s 0x8(%a6),%fp0 # load sgl dst 4298 fmov.x %fp0,FP_DST(%a6) 4303 fmov.s 0xc(%a6),%fp0 # load sgl src 4304 fmov.x %fp0,FP_SRC(%a6) 4356 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4363 fmov.d 0x8(%a6),%fp0 # load dbl dst 4364 fmov.x %fp0,FP_DST(%a6) 4369 fmov.d 0x10(%a6),%fp0 # load dbl src 4370 fmov.x %fp0,FP_SRC(%a6) 4422 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4494 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4501 fmov.s 0x8(%a6),%fp0 # load sgl dst 4502 fmov.x %fp0,FP_DST(%a6) 4507 fmov.s 0xc(%a6),%fp0 # load sgl src 4508 fmov.x %fp0,FP_SRC(%a6) 4560 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4567 fmov.d 0x8(%a6),%fp0 # load dbl dst 4568 fmov.x %fp0,FP_DST(%a6) 4573 fmov.d 0x10(%a6),%fp0 # load dbl src 4574 fmov.x %fp0,FP_SRC(%a6) 4626 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4698 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4705 fmov.s 0x8(%a6),%fp0 # load sgl dst 4706 fmov.x %fp0,FP_DST(%a6) 4711 fmov.s 0xc(%a6),%fp0 # load sgl src 4712 fmov.x %fp0,FP_SRC(%a6) 4764 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4771 fmov.d 0x8(%a6),%fp0 # load dbl dst 4772 fmov.x %fp0,FP_DST(%a6) 4777 fmov.d 0x10(%a6),%fp0 # load dbl src 4778 fmov.x %fp0,FP_SRC(%a6) 4830 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4906 # fp0 = sin(X) or cos(X) # 4909 # fp0 = sin(X) # 5028 fmov.x (%a0),%fp0 # LOAD INPUT 5029 fmov.x %fp0,X(%a6) # save input at X 5048 fmov.x %fp0,%fp1 5061 fsub.x (%a1)+,%fp0 # X-Y1 5062 fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2 5085 fmov.x %fp0,X(%a6) # X IS R 5086 fmul.x %fp0,%fp0 # FP0 IS S 5091 fmov.x %fp0,%fp1 5113 fmul.x %fp0,%fp2 # S(A2+T(A4+TA6)) 5115 fmul.x X(%a6),%fp0 # R'*S 5119 fmul.x %fp1,%fp0 # SIN(R')-R' 5124 fadd.x X(%a6),%fp0 # last inst - possible exception set 5139 fmul.x %fp0,%fp0 # FP0 IS S 5144 fmov.x %fp0,%fp1 5147 fmov.x %fp0,X(%a6) # X IS S 5177 fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8))) 5179 fadd.x %fp1,%fp0 5181 fmul.x X(%a6),%fp0 5186 fadd.s POSNEG1(%a6),%fp0 # last inst - possible exception set 5210 fmov.x X(%a6),%fp0 # last inst - possible exception set 5214 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5216 fadd.s &0x80800000,%fp0 # last inst - possible exception set 5229 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5239 fmov.x (%a0),%fp0 # LOAD INPUT 5240 fmov.x %fp0,X(%a6) 5259 fmov.x %fp0,%fp1 5271 fsub.x (%a1)+,%fp0 # X-Y1 5272 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5286 fmov.x %fp0,RPRIME(%a6) 5287 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5290 fmul.x %fp0,%fp1 # SA7 5291 fmul.x %fp0,%fp2 # SB8 5303 fmul.x %fp0,%fp1 # S(A6+SA7) 5306 fmul.x %fp0,%fp2 # S(B7+SB8) 5315 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7)) 5316 fmul.x %fp0,%fp2 # S(B6+S(B7+SB8)) 5317 fmov.x %fp0,SPRIME(%a6) 5323 fmul.x %fp0,%fp1 # S(A4+...) 5324 fmul.x %fp0,%fp2 # S(B5+...) 5329 fmul.x %fp0,%fp1 # S(A3+...) 5330 fmul.x %fp0,%fp2 # S(B4+...) 5335 fmul.x %fp0,%fp1 # S(A2+...) 5336 fmul.x %fp0,%fp2 # S(B3+...) 5341 fmul.x %fp0,%fp1 # S(A1+...) 5342 fmul.x %fp2,%fp0 # S(B2+...) 5345 fadd.s COSB1(%pc),%fp0 # B1+S(B2...) 5346 fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...)) 5353 fadd.s POSNEG1(%a6),%fp0 # SIN(X) 5360 fmov.x %fp0,RPRIME(%a6) 5361 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5366 fmul.x %fp0,%fp1 # SB8 5367 fmov.x %fp0,SPRIME(%a6) 5368 fmul.x %fp0,%fp2 # SA7 5379 fmul.x %fp0,%fp1 # S(B7+SB8) 5384 fmul.x %fp0,%fp2 # S(A6+SA7) 5389 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8)) 5390 fmul.x %fp0,%fp2 # S(A5+S(A6+SA7)) 5395 fmul.x %fp0,%fp1 # S(B5+...) 5396 fmul.x %fp0,%fp2 # S(A4+...) 5401 fmul.x %fp0,%fp1 # S(B4+...) 5402 fmul.x %fp0,%fp2 # S(A3+...) 5407 fmul.x %fp0,%fp1 # S(B3+...) 5408 fmul.x %fp0,%fp2 # S(A2+...) 5413 fmul.x %fp0,%fp1 # S(B2+...) 5414 fmul.x %fp2,%fp0 # s(a1+...) 5418 fmul.x RPRIME(%a6),%fp0 # R'S(A1+...) 5426 fadd.x RPRIME(%a6),%fp0 # SIN(X) 5446 fmov.x X(%a6),%fp0 5487 ftest.x %fp0 # test sign of argument 5493 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 5494 fmov.x %fp0,%fp1 # save high result in fp1 5495 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 5496 fsub.x %fp0,%fp1 # determine low component of result 5497 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 5503 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 5532 fmov.x %fp0,%fp2 5577 fsub.x %fp3,%fp0 # fp0 = A := R - P 5580 fmov.x %fp0,%fp3 # fp3 = A 5585 fadd.x %fp1,%fp0 # fp0 = R := A+a 5591 fsub.x %fp0,%fp3 # fp3 = A-R 5615 # fp0 = tan(X) # 5760 fmov.x (%a0),%fp0 # LOAD INPUT 5777 fmov.x %fp0,%fp1 5787 fsub.x (%a1)+,%fp0 # X-Y1 5789 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5800 fmov.x %fp0,%fp1 5822 fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3)) 5826 fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3)) 5833 fdiv.x %fp1,%fp0 # last inst - possible exception set 5837 fmov.x %fp0,%fp1 5838 fmul.x %fp0,%fp0 # S = R*R 5843 fmul.x %fp0,%fp3 # SQ4 5844 fmul.x %fp0,%fp2 # SP3 5849 fmul.x %fp0,%fp3 # S(Q3+SQ4) 5850 fmul.x %fp0,%fp2 # S(P2+SP3) 5855 fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4)) 5856 fmul.x %fp0,%fp2 # S(P1+S(P2+SP3)) 5861 fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4))) 5864 fadd.s &0x3F800000,%fp0 # 1+S(Q1+...) 5872 fdiv.x (%sp)+,%fp0 # last inst - possible exception set 5882 fmov.x %fp0,-(%sp) 5885 fmov.x (%sp)+,%fp0 # last inst - posibble exception set 5918 ftest.x %fp0 # test sign of argument 5924 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 5925 fmov.x %fp0,%fp1 # save high result in fp1 5926 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 5927 fsub.x %fp0,%fp1 # determine low component of result 5928 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 5934 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 5963 fmov.x %fp0,%fp2 6008 fsub.x %fp3,%fp0 # fp0 = A := R - P 6011 fmov.x %fp0,%fp3 # fp3 = A 6016 fadd.x %fp1,%fp0 # fp0 = R := A+a 6022 fsub.x %fp0,%fp3 # fp3 = A-R 6045 # fp0 = arctan(X) # 6242 fmov.x (%a0),%fp0 # LOAD INPUT 6246 fmov.x %fp0,X(%a6) 6285 fmov.x %fp0,%fp1 # FP1 IS X 6287 fsub.x X(%a6),%fp0 # FP0 IS X-F 6289 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F) 6326 fmov.x %fp0,%fp1 6331 fmul.x %fp0,%fp1 # U*V 6335 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED 6340 fadd.x ATANF(%a6),%fp0 # ATAN(X) 6362 fmul.x %fp0,%fp0 # FPO IS Y = X*X 6364 fmov.x %fp0,%fp1 6382 fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6)) 6383 fmul.x X(%a6),%fp0 # X*Y 6387 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) 6392 fadd.x X(%a6),%fp0 6400 fmov.x X(%a6),%fp0 # last inst - possible exception set 6418 fdiv.x %fp0,%fp1 # FP1 IS -1/X 6422 fmov.x %fp1,%fp0 # FP0 IS X' 6423 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X' 6426 fmov.x %fp0,%fp1 6439 fmul.x %fp0,%fp2 # Y*(C2+Z*C4) 6442 fmul.x X(%a6),%fp0 # X'*Y 6446 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)] 6448 fadd.x X(%a6),%fp0 6457 fadd.x NPIBY2(%pc),%fp0 6461 fadd.x PPIBY2(%pc),%fp0 6470 fmov.x NPIBY2(%pc),%fp0 6472 fadd.x PTINY(%pc),%fp0 6476 fmov.x PPIBY2(%pc),%fp0 6478 fadd.x NTINY(%pc),%fp0 6495 # fp0 = arcsin(X) # 6524 fmov.x (%a0),%fp0 # LOAD INPUT 6545 fsub.x %fp0,%fp1 # 1-X 6548 fadd.x %fp0,%fp2 # 1+X 6552 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X]) 6560 fabs.x %fp0 # |X| 6561 fcmp.s %fp0,&0x3F800000 6566 fmov.x PIBY2(%pc),%fp0 6572 fmul.s (%sp)+,%fp0 6579 fmov.x (%a0),%fp0 # last inst - possible exception 6596 # fp0 = arccos(X) # 6625 fmov.x (%a0),%fp0 # LOAD INPUT 6638 fadd.x %fp0,%fp1 # 1+X 6639 fneg.x %fp0 # -X 6640 fadd.s &0x3F800000,%fp0 # 1-X 6641 fdiv.x %fp1,%fp0 # (1-X)/(1+X) 6642 fsqrt.x %fp0 # SQRT((1-X)/(1+X)) 6651 fadd.x %fp0,%fp0 # 2 * ATAN( STUFF ) 6655 fabs.x %fp0 6656 fcmp.s %fp0,&0x3F800000 6666 fmov.x PI(%pc),%fp0 # load PI 6668 fadd.s &0x00800000,%fp0 # add a small value 6678 fmov.x PIBY2(%pc),%fp0 6692 # fp0 = exp(X) or exp(X)-1 # 7121 fmov.x (%a0),%fp0 # load input from (a0) 7123 fmov.x %fp0,%fp1 7124 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7127 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7129 fmov.l %d1,%fp0 # convert to floating-format 7142 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7144 fmov.x %fp0,%fp2 7145 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7147 fadd.x %fp1,%fp0 # X + N*L1 7148 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7156 fmov.x %fp0,%fp1 7176 fmul.x %fp0,%fp3 # fp3 IS R*S*(A2+S*A4) 7179 fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4), 7182 fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1 7188 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1) 7190 fadd.s (%a1),%fp0 # accurate 2^(J/64) 7192 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*... 7199 fmul.x ADJSCALE(%a6),%fp0 7203 fmul.x SCALE(%a6),%fp0 # multiply 2^(M) 7210 fadd.s &0x3F800000,%fp0 # 1+X in user mode 7218 fmov.x (%a0),%fp0 # load input from (a0) 7220 fmov.x %fp0,%fp1 7221 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7224 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7226 fmov.l %d1,%fp0 # convert to floating-format 7257 fmov.s &0x3F800000,%fp0 7260 fadd.s (%sp)+,%fp0 7286 fmov.x (%a0),%fp0 # load input from (a0) 7288 fmov.x %fp0,%fp1 7289 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7291 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7293 fmov.l %d1,%fp0 # convert to floating-format 7304 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7306 fmov.x %fp0,%fp2 7307 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7309 fadd.x %fp1,%fp0 # X + N*L1 7310 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7319 fmov.x %fp0,%fp1 7349 fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6)) 7350 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5)) 7352 fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1 7359 fmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1) 7369 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released 7370 fadd.x (%a1),%fp0 # T+(p+(t+OnebySc)) 7378 fadd.s 12(%a1),%fp0 # p+t 7379 fadd.x (%a1),%fp0 # T+(p+t) 7380 fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t)) 7385 fadd.s (%a1),%fp0 # fp0 is p+t 7387 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t) 7392 fmul.x SC(%a6),%fp0 7408 fmov.x (%a0),%fp0 7411 fadd.x SC(%a6),%fp0 7416 fmov.x (%a0),%fp0 7417 fmul.d TWO140(%pc),%fp0 7421 fadd.x SC(%a6),%fp0 7424 fmul.d TWON140(%pc),%fp0 7429 fmov.x (%a0),%fp0 # fp0 is X 7430 fmul.x %fp0,%fp0 # fp0 is S := X*X 7433 fmul.x %fp0,%fp1 # fp1 is S*B12 7437 fmul.x %fp0,%fp2 # fp2 is S*B11 7438 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ... 7443 fmul.x %fp0,%fp2 # fp2 is S*(B9+... 7444 fmul.x %fp0,%fp1 # fp1 is S*(B8+... 7449 fmul.x %fp0,%fp2 # fp2 is S*(B7+... 7450 fmul.x %fp0,%fp1 # fp1 is S*(B6+... 7455 fmul.x %fp0,%fp2 # fp2 is S*(B5+... 7456 fmul.x %fp0,%fp1 # fp1 is S*(B4+... 7461 fmul.x %fp0,%fp2 # fp2 is S*(B3+... 7462 fmul.x %fp0,%fp1 # fp1 is S*(B2+... 7464 fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...) 7467 fmul.s &0x3F000000,%fp0 # fp0 is S*B1 7472 fadd.x %fp1,%fp0 # fp0 is S*B1+Q 7475 fadd.x (%a0),%fp0 7484 fmov.s &0xBF800000,%fp0 # fp0 is -1 7486 fadd.s &0x00800000,%fp0 # -1 + 2^(-126) 7498 # returned as an extended precision number in fp0. # 7503 # an exponent of $3fff and is returned in fp0. The range of # 7511 # fp0 = exponent(X) or mantissa(X) # 7520 fmov.w %d0,%fp0 # return exp in fp0 7533 fmov.w %d0,%fp0 # return exp in fp0 7547 fmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0 7573 # fp0 = cosh(X) # 7615 fmov.x (%a0),%fp0 # LOAD INPUT 7626 fabs.x %fp0 # |X| 7634 fmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|) 7638 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|)) 7642 fadd.x %fp1,%fp0 7649 fabs.x %fp0 7650 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7651 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7655 fmovm.x &0x01,-(%sp) # save fp0 to stack 7656 lea (%sp),%a0 # pass ptr to fp0 7658 add.l &0xc,%sp # clear fp0 from stack 7663 fmul.x TWO16380(%pc),%fp0 7672 fmov.s &0x3F800000,%fp0 7675 fadd.s &0x00800000,%fp0 7687 # fp0 = sinh(X) # 7727 fmov.x (%a0),%fp0 # LOAD INPUT 7739 fabs.x %fp0 # Y = |X| 7750 fmov.x %fp0,%fp1 7752 fmov.x %fp0,-(%sp) 7753 fdiv.x %fp1,%fp0 # Z/(1+Z) 7757 fadd.x (%sp)+,%fp0 7762 fmul.s (%sp)+,%fp0 # last fp inst - possible exceptions set 7768 fabs.x %fp0 7769 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7776 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7780 fmovm.x &0x01,-(%sp) # save fp0 on stack 7781 lea (%sp),%a0 # pass ptr to fp0 7783 add.l &0xc,%sp # clear fp0 from stack 7788 fmul.x (%sp)+,%fp0 # possible exception 7805 # fp0 = tanh(X) # 7852 fmov.x (%a0),%fp0 # LOAD INPUT 7854 fmov.x %fp0,X(%a6) 7873 fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X| 7883 fmov.x %fp0,%fp1 7890 fdiv.x V(%a6),%fp0 7911 fmov.x X(%a6),%fp0 # Y = 2|X| 7921 fadd.s &0x3F800000,%fp0 # EXP(Y)+1 7925 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ] 7929 fmov.s %d1,%fp0 # SGN IN SGL FMT 7933 fadd.x %fp1,%fp0 7939 fmov.x X(%a6),%fp0 # last inst - possible exception set 7947 fmov.s %d1,%fp0 7952 fadd.s %d1,%fp0 7971 # fp0 = log(X) or log(1+X) # 8214 fmov.x (%a0),%fp0 # LOAD INPUT 8268 fmov.x X(%a6),%fp0 8271 fsub.x F(%a6),%fp0 # Y-F 8278 fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/F 8280 fmov.x %fp0,%fp2 8307 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6)) 8308 fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5)) 8312 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U) 8315 fadd.x KLOG2(%a6),%fp0 # FINAL ADD 8324 fcmp.b %fp0,&0x1 # is it equal to one? 8328 fmov.x %fp0,%fp1 8330 fadd.s one(%pc),%fp0 # FP0 IS X+1 8337 fdiv.x %fp0,%fp1 # FP1 IS U 8343 fmov.x %fp1,%fp0 8344 fmul.x %fp0,%fp0 # FP0 IS V 8346 fmov.x %fp0,%fp1 8360 fmul.x %fp0,%fp2 # V*(B2+W*B4) 8363 fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V 8368 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] ) 8371 fadd.x SAVEU(%a6),%fp0 8412 fmov.x X(%a6),%fp0 8434 fmov.x X(%a6),%fp0 8442 fmov.x (%a0),%fp0 # LOAD INPUT 8443 fabs.x %fp0 # test magnitude 8444 fcmp.x %fp0,LTHOLD(%pc) # compare with min threshold 8448 fmov.x (%a0),%fp0 # return signed argument 8452 fmov.x (%a0),%fp0 # LOAD INPUT 8454 fmov.x %fp0,%fp1 # FP1 IS INPUT Z 8455 fadd.s one(%pc),%fp0 # X := ROUND(1+Z) 8456 fmov.x %fp0,X(%a6) 8480 fadd.s one(%pc),%fp0 # FP0 IS 1+X 8501 fmov.s TWO(%pc),%fp0 8504 fsub.x F(%a6),%fp0 # 2-F 8512 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z 8519 fmov.s one(%pc),%fp0 8522 fsub.x F(%a6),%fp0 # 1-F 8528 fadd.x %fp1,%fp0 # FP0 IS Y-F 8540 fmov.s negone(%pc),%fp0 8546 fmov.s zero(%pc),%fp0 8566 # fp0 = arctanh(X) # 8610 fabs.x (%a0),%fp0 # Y = |X| 8611 fmov.x %fp0,%fp1 8613 fadd.x %fp0,%fp0 # 2Y 8615 fdiv.x %fp1,%fp0 # 2Y/(1-Y) 8631 fmul.s (%sp)+,%fp0 8635 fabs.x (%a0),%fp0 # |X| 8636 fcmp.s %fp0,&0x3F800000 8656 # fp0 = log_10(X) or log_2(X) # 8739 fmov.b &0x1,%fp0 8740 fcmp.x %fp0,(%a0) # if operand == 1, 8749 fmul.x INV_L10(%pc),%fp0 8761 fmul.x INV_L10(%pc),%fp0 8783 fmov.l %d1,%fp0 8791 fmul.x INV_L2(%pc),%fp0 8806 fmul.x INV_L2(%pc),%fp0 8820 # fp0 = 2**X or 10**X # 8990 fmov.x %fp0,X(%a6) 9005 fmov.x %fp0,%fp1 9035 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X) 9041 fmul.x LOG2(%pc),%fp0 # FP0 IS R 9054 fadd.s &0x3F800000,%fp0 # RETURN 1 + X 9074 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9077 fadd.s %d1,%fp0 9087 fmov.x %fp0,X(%a6) 9102 fmov.x %fp0,%fp1 9134 fsub.x %fp1,%fp0 # X - N L_LEAD 9137 fsub.x %fp2,%fp0 # X - N L_TRAIL 9143 fmul.x LOG10(%pc),%fp0 # FP0 IS R 9153 fmov.x %fp0,%fp1 9169 fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4) 9172 fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4) 9173 fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1 9180 fmul.x FACT1(%a6),%fp0 9181 fadd.x FACT2(%a6),%fp0 9182 fadd.x FACT1(%a6),%fp0 9190 fmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENT 9198 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9201 fadd.s %d1,%fp0 9214 # fp0 = scale(X,Y) # 9239 fintrz.x SRC(%a0),%fp0 # calc int of src 9240 fmov.l %fp0,%d0 # int src to d0 9295 fmovm.x DST(%a1),&0x80 # load fp0 with normalized src 9308 fmul.x (%sp)+,%fp0 # do the multiply 9333 fmov.x DST(%a1),%fp0 # simply return dest 9353 # fp0 = FREM(X,Y) or FMOD(X,Y) # 9629 fmov.x R(%a6),%fp0 # no exception 9640 fmov.x R(%a6),%fp0 9668 fsub.x Y(%a6),%fp0 # no exceptions 9676 fneg.x %fp0 9702 fmul.x Scale(%pc),%fp0 # may cause underflow 9706 # algorithm just got done playing with fp0 and expected no exceptions 9713 fmov.x %fp0,%fp0 # capture exceptions & round 9729 fmov.s &0x00000000,%fp0 9834 # fp0 = default DZ result. # 9841 # in fp0 while fp1 is used to create a DZ exception so that the # 9859 fmov.s &0xff800000,%fp0 # return -INF 9863 # but use fp1 instead. return the dst operand unscathed in fp0. 9865 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9878 fmov.s &0x7f800000,%fp0 # return +INF 9882 # but use fp1 instead. return the dst operand unscathed in fp0. 9884 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9903 # fp0 = default result # 9909 # in fp0. If OPERR is enabled, return the dst operand unscathed in fp0 # 9922 # operr is disabled. return a QNAN in fp0 9927 # but use fp2 instead. return the dst operand unscathed in fp0. 9929 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9961 # fp0 = default underflow result # 9982 fmul.x pls_tiny(%pc),%fp0 9993 fmul.x %fp0,%fp0 10018 # fp0 = default underflow result # 10073 fmul.x pls_huge(%pc),%fp0 10083 fmul.x pls_huge(%pc),%fp0 10095 fmul.x pls_huge(%pc),%fp0 10115 # fp0 = default underflow or overflow result # 10118 # fp0 = default result # 10149 # fp0 = default result # 10152 # fp0 = default result # 10207 # fp0 = default result # 10220 fmov.x SRC_EX(%a0),%fp0 10229 fmov.x SRC_EX(%a0),%fp0 10239 # values are already in fp0 and fp1 so we do nothing here. 10252 fmov.x DST(%a1),%fp0 10267 fmov.x SRC(%a0),%fp0 10290 fmov.s 0x8(%sp),%fp0 # load sgl dst 10292 fadd.s 0x8(%sp),%fp0 # fadd w/ sgl src 10299 fmov.d 0x8(%sp),%fp0 # load dbl dst 10301 fadd.d 0xc(%sp),%fp0 # fadd w/ dbl src 10307 fadd.x 0x10(%sp),%fp0 # fadd w/ ext src 10314 fmov.s 0x8(%sp),%fp0 # load sgl dst 10316 fsub.s 0x8(%sp),%fp0 # fsub w/ sgl src 10323 fmov.d 0x8(%sp),%fp0 # load dbl dst 10325 fsub.d 0xc(%sp),%fp0 # fsub w/ dbl src 10331 fsub.x 0x10(%sp),%fp0 # fsub w/ ext src 10338 fmov.s 0x8(%sp),%fp0 # load sgl dst 10340 fmul.s 0x8(%sp),%fp0 # fmul w/ sgl src 10347 fmov.d 0x8(%sp),%fp0 # load dbl dst 10349 fmul.d 0xc(%sp),%fp0 # fmul w/ dbl src 10355 fmul.x 0x10(%sp),%fp0 # fmul w/ ext src 10362 fmov.s 0x8(%sp),%fp0 # load sgl dst 10364 fdiv.s 0x8(%sp),%fp0 # fdiv w/ sgl src 10371 fmov.d 0x8(%sp),%fp0 # load dbl dst 10373 fdiv.d 0xc(%sp),%fp0 # fdiv w/ dbl src 10379 fdiv.x 0x10(%sp),%fp0 # fdiv w/ ext src 10384 fabs.s 0x4(%sp),%fp0 # fabs w/ sgl src 10389 fabs.d 0x4(%sp),%fp0 # fabs w/ dbl src 10394 fabs.x 0x4(%sp),%fp0 # fabs w/ ext src 10399 fneg.s 0x4(%sp),%fp0 # fneg w/ sgl src 10404 fneg.d 0x4(%sp),%fp0 # fneg w/ dbl src 10409 fneg.x 0x4(%sp),%fp0 # fneg w/ ext src 10414 fsqrt.s 0x4(%sp),%fp0 # fsqrt w/ sgl src 10419 fsqrt.d 0x4(%sp),%fp0 # fsqrt w/ dbl src 10424 fsqrt.x 0x4(%sp),%fp0 # fsqrt w/ ext src 10429 fint.s 0x4(%sp),%fp0 # fint w/ sgl src 10434 fint.d 0x4(%sp),%fp0 # fint w/ dbl src 10439 fint.x 0x4(%sp),%fp0 # fint w/ ext src 10444 fintrz.s 0x4(%sp),%fp0 # fintrz w/ sgl src 10449 fintrz.d 0x4(%sp),%fp0 # fintrx w/ dbl src 10454 fintrz.x 0x4(%sp),%fp0 # fintrz w/ ext src 10472 fmov.s &0x00000000,%fp0 # load +0 10479 fmov.s &0x80000000,%fp0 # load -0 10505 fmov.s &0x7f800000,%fp0 # load +INF 10514 fmov.s &0xff800000,%fp0 # load -INF 10573 fmov.s &0x3f800000,%fp0 # load +1 10582 fmov.s &0xbf800000,%fp0 # load -1 10603 fmov.x ppiby2(%pc),%fp0 # load +pi/2 10612 fmov.x mpiby2(%pc),%fp0 # load -pi/2 10621 # cosine register and return a ZERO in fp0 w/ the same sign 10629 fmov.s &0x80000000,%fp0 # return sin result in fp0 10633 fmov.s &0x00000000,%fp0 # return sin result in fp0 10723 fmov.x DST(%a1),%fp0
|
H A D | fpsp.S | 327 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0 647 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 715 # the operation has been emulated. the result is in fp0. 731 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 746 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 765 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 804 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 887 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 981 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 990 # in fp1 (don't forget to save fp0). what to do now? 1008 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1039 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1078 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1212 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 1338 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1405 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1570 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1587 # the extended precision result is still in fp0. but, we need to save it 1590 # for fp0/fp1 which have already been restored. that way, we can write 1594 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1677 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1692 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1709 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1738 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1755 # the extended precision result is still in fp0. but, we need to save it 1762 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1790 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1890 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1908 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1989 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2020 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2121 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2139 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2189 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2229 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2269 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2468 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 2637 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 2697 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 2779 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2796 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2809 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2898 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3020 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack 3047 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack 3115 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3139 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3311 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3335 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3532 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3603 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3627 fmov.l FP_SRC_HI(%a6),%fp0 # load integer src 3628 fmov.x %fp0,FP_SRC(%a6) # store integer as extended precision 3686 # the operation has been emulated. the result is in fp0. 3692 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3777 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3797 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 4023 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 4105 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4243 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4303 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4362 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4410 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4431 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 4980 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 5012 # fp0 = sin(X) or cos(X) # 5015 # fp0 = sin(X) # 5134 fmov.x (%a0),%fp0 # LOAD INPUT 5135 fmov.x %fp0,X(%a6) # save input at X 5154 fmov.x %fp0,%fp1 5167 fsub.x (%a1)+,%fp0 # X-Y1 5168 fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2 5191 fmov.x %fp0,X(%a6) # X IS R 5192 fmul.x %fp0,%fp0 # FP0 IS S 5197 fmov.x %fp0,%fp1 5219 fmul.x %fp0,%fp2 # S(A2+T(A4+TA6)) 5221 fmul.x X(%a6),%fp0 # R'*S 5225 fmul.x %fp1,%fp0 # SIN(R')-R' 5230 fadd.x X(%a6),%fp0 # last inst - possible exception set 5245 fmul.x %fp0,%fp0 # FP0 IS S 5250 fmov.x %fp0,%fp1 5253 fmov.x %fp0,X(%a6) # X IS S 5283 fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8))) 5285 fadd.x %fp1,%fp0 5287 fmul.x X(%a6),%fp0 5292 fadd.s POSNEG1(%a6),%fp0 # last inst - possible exception set 5316 fmov.x X(%a6),%fp0 # last inst - possible exception set 5320 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5322 fadd.s &0x80800000,%fp0 # last inst - possible exception set 5335 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5345 fmov.x (%a0),%fp0 # LOAD INPUT 5346 fmov.x %fp0,X(%a6) 5365 fmov.x %fp0,%fp1 5377 fsub.x (%a1)+,%fp0 # X-Y1 5378 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5392 fmov.x %fp0,RPRIME(%a6) 5393 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5396 fmul.x %fp0,%fp1 # SA7 5397 fmul.x %fp0,%fp2 # SB8 5409 fmul.x %fp0,%fp1 # S(A6+SA7) 5412 fmul.x %fp0,%fp2 # S(B7+SB8) 5421 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7)) 5422 fmul.x %fp0,%fp2 # S(B6+S(B7+SB8)) 5423 fmov.x %fp0,SPRIME(%a6) 5429 fmul.x %fp0,%fp1 # S(A4+...) 5430 fmul.x %fp0,%fp2 # S(B5+...) 5435 fmul.x %fp0,%fp1 # S(A3+...) 5436 fmul.x %fp0,%fp2 # S(B4+...) 5441 fmul.x %fp0,%fp1 # S(A2+...) 5442 fmul.x %fp0,%fp2 # S(B3+...) 5447 fmul.x %fp0,%fp1 # S(A1+...) 5448 fmul.x %fp2,%fp0 # S(B2+...) 5451 fadd.s COSB1(%pc),%fp0 # B1+S(B2...) 5452 fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...)) 5459 fadd.s POSNEG1(%a6),%fp0 # SIN(X) 5466 fmov.x %fp0,RPRIME(%a6) 5467 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5472 fmul.x %fp0,%fp1 # SB8 5473 fmov.x %fp0,SPRIME(%a6) 5474 fmul.x %fp0,%fp2 # SA7 5485 fmul.x %fp0,%fp1 # S(B7+SB8) 5490 fmul.x %fp0,%fp2 # S(A6+SA7) 5495 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8)) 5496 fmul.x %fp0,%fp2 # S(A5+S(A6+SA7)) 5501 fmul.x %fp0,%fp1 # S(B5+...) 5502 fmul.x %fp0,%fp2 # S(A4+...) 5507 fmul.x %fp0,%fp1 # S(B4+...) 5508 fmul.x %fp0,%fp2 # S(A3+...) 5513 fmul.x %fp0,%fp1 # S(B3+...) 5514 fmul.x %fp0,%fp2 # S(A2+...) 5519 fmul.x %fp0,%fp1 # S(B2+...) 5520 fmul.x %fp2,%fp0 # s(a1+...) 5524 fmul.x RPRIME(%a6),%fp0 # R'S(A1+...) 5532 fadd.x RPRIME(%a6),%fp0 # SIN(X) 5552 fmov.x X(%a6),%fp0 5593 ftest.x %fp0 # test sign of argument 5599 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 5600 fmov.x %fp0,%fp1 # save high result in fp1 5601 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 5602 fsub.x %fp0,%fp1 # determine low component of result 5603 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 5609 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 5638 fmov.x %fp0,%fp2 5683 fsub.x %fp3,%fp0 # fp0 = A := R - P 5686 fmov.x %fp0,%fp3 # fp3 = A 5691 fadd.x %fp1,%fp0 # fp0 = R := A+a 5697 fsub.x %fp0,%fp3 # fp3 = A-R 5721 # fp0 = tan(X) # 5866 fmov.x (%a0),%fp0 # LOAD INPUT 5883 fmov.x %fp0,%fp1 5893 fsub.x (%a1)+,%fp0 # X-Y1 5895 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5906 fmov.x %fp0,%fp1 5928 fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3)) 5932 fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3)) 5939 fdiv.x %fp1,%fp0 # last inst - possible exception set 5943 fmov.x %fp0,%fp1 5944 fmul.x %fp0,%fp0 # S = R*R 5949 fmul.x %fp0,%fp3 # SQ4 5950 fmul.x %fp0,%fp2 # SP3 5955 fmul.x %fp0,%fp3 # S(Q3+SQ4) 5956 fmul.x %fp0,%fp2 # S(P2+SP3) 5961 fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4)) 5962 fmul.x %fp0,%fp2 # S(P1+S(P2+SP3)) 5967 fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4))) 5970 fadd.s &0x3F800000,%fp0 # 1+S(Q1+...) 5978 fdiv.x (%sp)+,%fp0 # last inst - possible exception set 5988 fmov.x %fp0,-(%sp) 5991 fmov.x (%sp)+,%fp0 # last inst - posibble exception set 6024 ftest.x %fp0 # test sign of argument 6030 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 6031 fmov.x %fp0,%fp1 # save high result in fp1 6032 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 6033 fsub.x %fp0,%fp1 # determine low component of result 6034 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 6040 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 6069 fmov.x %fp0,%fp2 6114 fsub.x %fp3,%fp0 # fp0 = A := R - P 6117 fmov.x %fp0,%fp3 # fp3 = A 6122 fadd.x %fp1,%fp0 # fp0 = R := A+a 6128 fsub.x %fp0,%fp3 # fp3 = A-R 6151 # fp0 = arctan(X) # 6348 fmov.x (%a0),%fp0 # LOAD INPUT 6352 fmov.x %fp0,X(%a6) 6391 fmov.x %fp0,%fp1 # FP1 IS X 6393 fsub.x X(%a6),%fp0 # FP0 IS X-F 6395 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F) 6432 fmov.x %fp0,%fp1 6437 fmul.x %fp0,%fp1 # U*V 6441 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED 6446 fadd.x ATANF(%a6),%fp0 # ATAN(X) 6468 fmul.x %fp0,%fp0 # FPO IS Y = X*X 6470 fmov.x %fp0,%fp1 6488 fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6)) 6489 fmul.x X(%a6),%fp0 # X*Y 6493 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) 6498 fadd.x X(%a6),%fp0 6506 fmov.x X(%a6),%fp0 # last inst - possible exception set 6524 fdiv.x %fp0,%fp1 # FP1 IS -1/X 6528 fmov.x %fp1,%fp0 # FP0 IS X' 6529 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X' 6532 fmov.x %fp0,%fp1 6545 fmul.x %fp0,%fp2 # Y*(C2+Z*C4) 6548 fmul.x X(%a6),%fp0 # X'*Y 6552 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)] 6554 fadd.x X(%a6),%fp0 6563 fadd.x NPIBY2(%pc),%fp0 6567 fadd.x PPIBY2(%pc),%fp0 6576 fmov.x NPIBY2(%pc),%fp0 6578 fadd.x PTINY(%pc),%fp0 6582 fmov.x PPIBY2(%pc),%fp0 6584 fadd.x NTINY(%pc),%fp0 6601 # fp0 = arcsin(X) # 6630 fmov.x (%a0),%fp0 # LOAD INPUT 6651 fsub.x %fp0,%fp1 # 1-X 6654 fadd.x %fp0,%fp2 # 1+X 6658 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X]) 6666 fabs.x %fp0 # |X| 6667 fcmp.s %fp0,&0x3F800000 6672 fmov.x PIBY2(%pc),%fp0 6678 fmul.s (%sp)+,%fp0 6685 fmov.x (%a0),%fp0 # last inst - possible exception 6702 # fp0 = arccos(X) # 6731 fmov.x (%a0),%fp0 # LOAD INPUT 6744 fadd.x %fp0,%fp1 # 1+X 6745 fneg.x %fp0 # -X 6746 fadd.s &0x3F800000,%fp0 # 1-X 6747 fdiv.x %fp1,%fp0 # (1-X)/(1+X) 6748 fsqrt.x %fp0 # SQRT((1-X)/(1+X)) 6757 fadd.x %fp0,%fp0 # 2 * ATAN( STUFF ) 6761 fabs.x %fp0 6762 fcmp.s %fp0,&0x3F800000 6772 fmov.x PI(%pc),%fp0 # load PI 6774 fadd.s &0x00800000,%fp0 # add a small value 6784 fmov.x PIBY2(%pc),%fp0 6798 # fp0 = exp(X) or exp(X)-1 # 7227 fmov.x (%a0),%fp0 # load input from (a0) 7229 fmov.x %fp0,%fp1 7230 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7233 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7235 fmov.l %d1,%fp0 # convert to floating-format 7248 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7250 fmov.x %fp0,%fp2 7251 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7253 fadd.x %fp1,%fp0 # X + N*L1 7254 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7262 fmov.x %fp0,%fp1 7282 fmul.x %fp0,%fp3 # fp3 IS R*S*(A2+S*A4) 7285 fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4), 7288 fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1 7294 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1) 7296 fadd.s (%a1),%fp0 # accurate 2^(J/64) 7298 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*... 7305 fmul.x ADJSCALE(%a6),%fp0 7309 fmul.x SCALE(%a6),%fp0 # multiply 2^(M) 7316 fadd.s &0x3F800000,%fp0 # 1+X in user mode 7324 fmov.x (%a0),%fp0 # load input from (a0) 7326 fmov.x %fp0,%fp1 7327 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7330 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7332 fmov.l %d1,%fp0 # convert to floating-format 7363 fmov.s &0x3F800000,%fp0 7366 fadd.s (%sp)+,%fp0 7392 fmov.x (%a0),%fp0 # load input from (a0) 7394 fmov.x %fp0,%fp1 7395 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7397 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7399 fmov.l %d1,%fp0 # convert to floating-format 7410 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7412 fmov.x %fp0,%fp2 7413 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7415 fadd.x %fp1,%fp0 # X + N*L1 7416 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7425 fmov.x %fp0,%fp1 7455 fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6)) 7456 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5)) 7458 fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1 7465 fmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1) 7475 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released 7476 fadd.x (%a1),%fp0 # T+(p+(t+OnebySc)) 7484 fadd.s 12(%a1),%fp0 # p+t 7485 fadd.x (%a1),%fp0 # T+(p+t) 7486 fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t)) 7491 fadd.s (%a1),%fp0 # fp0 is p+t 7493 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t) 7498 fmul.x SC(%a6),%fp0 7514 fmov.x (%a0),%fp0 7517 fadd.x SC(%a6),%fp0 7522 fmov.x (%a0),%fp0 7523 fmul.d TWO140(%pc),%fp0 7527 fadd.x SC(%a6),%fp0 7530 fmul.d TWON140(%pc),%fp0 7535 fmov.x (%a0),%fp0 # fp0 is X 7536 fmul.x %fp0,%fp0 # fp0 is S := X*X 7539 fmul.x %fp0,%fp1 # fp1 is S*B12 7543 fmul.x %fp0,%fp2 # fp2 is S*B11 7544 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ... 7549 fmul.x %fp0,%fp2 # fp2 is S*(B9+... 7550 fmul.x %fp0,%fp1 # fp1 is S*(B8+... 7555 fmul.x %fp0,%fp2 # fp2 is S*(B7+... 7556 fmul.x %fp0,%fp1 # fp1 is S*(B6+... 7561 fmul.x %fp0,%fp2 # fp2 is S*(B5+... 7562 fmul.x %fp0,%fp1 # fp1 is S*(B4+... 7567 fmul.x %fp0,%fp2 # fp2 is S*(B3+... 7568 fmul.x %fp0,%fp1 # fp1 is S*(B2+... 7570 fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...) 7573 fmul.s &0x3F000000,%fp0 # fp0 is S*B1 7578 fadd.x %fp1,%fp0 # fp0 is S*B1+Q 7581 fadd.x (%a0),%fp0 7590 fmov.s &0xBF800000,%fp0 # fp0 is -1 7592 fadd.s &0x00800000,%fp0 # -1 + 2^(-126) 7604 # returned as an extended precision number in fp0. # 7609 # an exponent of $3fff and is returned in fp0. The range of # 7617 # fp0 = exponent(X) or mantissa(X) # 7626 fmov.w %d0,%fp0 # return exp in fp0 7639 fmov.w %d0,%fp0 # return exp in fp0 7653 fmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0 7679 # fp0 = cosh(X) # 7721 fmov.x (%a0),%fp0 # LOAD INPUT 7732 fabs.x %fp0 # |X| 7740 fmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|) 7744 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|)) 7748 fadd.x %fp1,%fp0 7755 fabs.x %fp0 7756 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7757 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7761 fmovm.x &0x01,-(%sp) # save fp0 to stack 7762 lea (%sp),%a0 # pass ptr to fp0 7764 add.l &0xc,%sp # clear fp0 from stack 7769 fmul.x TWO16380(%pc),%fp0 7778 fmov.s &0x3F800000,%fp0 7781 fadd.s &0x00800000,%fp0 7793 # fp0 = sinh(X) # 7833 fmov.x (%a0),%fp0 # LOAD INPUT 7845 fabs.x %fp0 # Y = |X| 7856 fmov.x %fp0,%fp1 7858 fmov.x %fp0,-(%sp) 7859 fdiv.x %fp1,%fp0 # Z/(1+Z) 7863 fadd.x (%sp)+,%fp0 7868 fmul.s (%sp)+,%fp0 # last fp inst - possible exceptions set 7874 fabs.x %fp0 7875 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7882 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7886 fmovm.x &0x01,-(%sp) # save fp0 on stack 7887 lea (%sp),%a0 # pass ptr to fp0 7889 add.l &0xc,%sp # clear fp0 from stack 7894 fmul.x (%sp)+,%fp0 # possible exception 7911 # fp0 = tanh(X) # 7958 fmov.x (%a0),%fp0 # LOAD INPUT 7960 fmov.x %fp0,X(%a6) 7979 fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X| 7989 fmov.x %fp0,%fp1 7996 fdiv.x V(%a6),%fp0 8017 fmov.x X(%a6),%fp0 # Y = 2|X| 8027 fadd.s &0x3F800000,%fp0 # EXP(Y)+1 8031 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ] 8035 fmov.s %d1,%fp0 # SGN IN SGL FMT 8039 fadd.x %fp1,%fp0 8045 fmov.x X(%a6),%fp0 # last inst - possible exception set 8053 fmov.s %d1,%fp0 8058 fadd.s %d1,%fp0 8077 # fp0 = log(X) or log(1+X) # 8320 fmov.x (%a0),%fp0 # LOAD INPUT 8374 fmov.x X(%a6),%fp0 8377 fsub.x F(%a6),%fp0 # Y-F 8384 fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/F 8386 fmov.x %fp0,%fp2 8413 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6)) 8414 fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5)) 8418 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U) 8421 fadd.x KLOG2(%a6),%fp0 # FINAL ADD 8430 fcmp.b %fp0,&0x1 # is it equal to one? 8434 fmov.x %fp0,%fp1 8436 fadd.s one(%pc),%fp0 # FP0 IS X+1 8443 fdiv.x %fp0,%fp1 # FP1 IS U 8449 fmov.x %fp1,%fp0 8450 fmul.x %fp0,%fp0 # FP0 IS V 8452 fmov.x %fp0,%fp1 8466 fmul.x %fp0,%fp2 # V*(B2+W*B4) 8469 fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V 8474 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] ) 8477 fadd.x SAVEU(%a6),%fp0 8518 fmov.x X(%a6),%fp0 8540 fmov.x X(%a6),%fp0 8548 fmov.x (%a0),%fp0 # LOAD INPUT 8549 fabs.x %fp0 # test magnitude 8550 fcmp.x %fp0,LTHOLD(%pc) # compare with min threshold 8554 fmov.x (%a0),%fp0 # return signed argument 8558 fmov.x (%a0),%fp0 # LOAD INPUT 8560 fmov.x %fp0,%fp1 # FP1 IS INPUT Z 8561 fadd.s one(%pc),%fp0 # X := ROUND(1+Z) 8562 fmov.x %fp0,X(%a6) 8586 fadd.s one(%pc),%fp0 # FP0 IS 1+X 8607 fmov.s TWO(%pc),%fp0 8610 fsub.x F(%a6),%fp0 # 2-F 8618 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z 8625 fmov.s one(%pc),%fp0 8628 fsub.x F(%a6),%fp0 # 1-F 8634 fadd.x %fp1,%fp0 # FP0 IS Y-F 8646 fmov.s negone(%pc),%fp0 8652 fmov.s zero(%pc),%fp0 8672 # fp0 = arctanh(X) # 8716 fabs.x (%a0),%fp0 # Y = |X| 8717 fmov.x %fp0,%fp1 8719 fadd.x %fp0,%fp0 # 2Y 8721 fdiv.x %fp1,%fp0 # 2Y/(1-Y) 8737 fmul.s (%sp)+,%fp0 8741 fabs.x (%a0),%fp0 # |X| 8742 fcmp.s %fp0,&0x3F800000 8762 # fp0 = log_10(X) or log_2(X) # 8845 fmov.b &0x1,%fp0 8846 fcmp.x %fp0,(%a0) # if operand == 1, 8855 fmul.x INV_L10(%pc),%fp0 8867 fmul.x INV_L10(%pc),%fp0 8889 fmov.l %d1,%fp0 8897 fmul.x INV_L2(%pc),%fp0 8912 fmul.x INV_L2(%pc),%fp0 8926 # fp0 = 2**X or 10**X # 9096 fmov.x %fp0,X(%a6) 9111 fmov.x %fp0,%fp1 9141 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X) 9147 fmul.x LOG2(%pc),%fp0 # FP0 IS R 9160 fadd.s &0x3F800000,%fp0 # RETURN 1 + X 9180 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9183 fadd.s %d1,%fp0 9193 fmov.x %fp0,X(%a6) 9208 fmov.x %fp0,%fp1 9240 fsub.x %fp1,%fp0 # X - N L_LEAD 9243 fsub.x %fp2,%fp0 # X - N L_TRAIL 9249 fmul.x LOG10(%pc),%fp0 # FP0 IS R 9259 fmov.x %fp0,%fp1 9275 fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4) 9278 fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4) 9279 fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1 9286 fmul.x FACT1(%a6),%fp0 9287 fadd.x FACT2(%a6),%fp0 9288 fadd.x FACT1(%a6),%fp0 9296 fmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENT 9304 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9307 fadd.s %d1,%fp0 9319 # fp0 = the ROM constant rounded to the user's rounding mode,prec # 9460 fmovm.x (%a0,%d1.w),&0x80 # return result in fp0 9479 fmovm.x (%a0),&0x80 # return rounded result in fp0 9573 # fp0 = scale(X,Y) # 9598 fintrz.x SRC(%a0),%fp0 # calc int of src 9599 fmov.l %fp0,%d0 # int src to d0 9654 fmovm.x DST(%a1),&0x80 # load fp0 with normalized src 9667 fmul.x (%sp)+,%fp0 # do the multiply 9692 fmov.x DST(%a1),%fp0 # simply return dest 9712 # fp0 = FREM(X,Y) or FMOD(X,Y) # 9988 fmov.x R(%a6),%fp0 # no exception 9999 fmov.x R(%a6),%fp0 10027 fsub.x Y(%a6),%fp0 # no exceptions 10035 fneg.x %fp0 10061 fmul.x Scale(%pc),%fp0 # may cause underflow 10065 # algorithm just got done playing with fp0 and expected no exceptions 10072 fmov.x %fp0,%fp0 # capture exceptions & round 10088 fmov.s &0x00000000,%fp0 10122 # fp0 = default result # 10125 # - Store properly signed INF into fp0. # 10137 fmov.s &0x7f800000,%fp0 # return +INF in fp0 10143 fmov.s &0xff800000,%fp0 # return -INF in fp0 10150 # nan bit; Store default NAN into fp0 # 10155 fmovm.x qnan(%pc),&0x80 # return default NAN in fp0 10198 fmovm.x (%a0),&0x80 # return default result in fp0 10243 fmovm.x (%a0),&0x80 # return default result in fp0 10255 fmovm.x (%a0),&0x80 # return default result in fp0 10322 fmovm.x (%a0),&0x80 # return default result in fp0 10335 fmovm.x (%a0),&0x80 # return default result in fp0 10491 fmov.s &0x00000000,%fp0 # load +0 10498 fmov.s &0x80000000,%fp0 # load -0 10524 fmov.s &0x7f800000,%fp0 # load +INF 10533 fmov.s &0xff800000,%fp0 # load -INF 10592 fmov.s &0x3f800000,%fp0 # load +1 10601 fmov.s &0xbf800000,%fp0 # load -1 10622 fmov.x ppiby2(%pc),%fp0 # load +pi/2 10631 fmov.x mpiby2(%pc),%fp0 # load -pi/2 10640 # cosine register and return a ZERO in fp0 w/ the same sign 10648 fmov.s &0x80000000,%fp0 # return sin result in fp0 10652 fmov.s &0x00000000,%fp0 # return sin result in fp0 10812 fmov.x DST(%a1),%fp0 10942 fmov.x DST(%a1),%fp0 # the fmove sets the SNAN bit 10952 fmov.x DST(%a1),%fp0 # return the non-signalling nan 10967 fmov.x SRC(%a0),%fp0 # the fmove sets the SNAN bit 10977 fmov.x SRC(%a0),%fp0 # return the non-signalling nan 11343 # fp0 = destination operand # 11348 # fp0 = result # 11378 fmovm.x &0x80,FP_DST(%a6) # dst op is in fp0 11541 # fp0 = result # 11628 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11646 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 11654 # - calculate the default result and return it in fp0. 11668 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11690 fmovm.x (%a0),&0x80 # return default result in fp0 11728 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11738 # - calculate the default result and return it in fp0. 11746 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11753 fabs.x %fp0,%fp1 # make a copy of result 11765 # - calculate the default result and return it in fp0. 11784 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11802 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 11857 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 11864 fabs.x %fp0,%fp1 # make a copy of result 11975 fmov.s &0x80000000,%fp0 # load -ZERO 11979 fmov.s &0x00000000,%fp0 # load +ZERO 11993 fmovm.x DST(%a1),&0x80 # return INF result in fp0 11999 fabs.x %fp0 # clear result sign 12000 fneg.x %fp0 # set result sign 12004 fabs.x %fp0 # clear result sign 12010 fmovm.x SRC(%a0),&0x80 # return INF result in fp0 12036 # fp0 = result # 12085 fmovm.x SRC(%a0),&0x80 # return result in fp0 12101 fmovm.x SRC(%a0),&0x80 # return result in fp0 12156 fmov.x FP_SCR0(%a6),%fp0 # perform move 12174 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 12214 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 12246 fmov.x FP_SCR0(%a6),%fp0 # perform move 12270 fmovm.x (%a0),&0x80 # return default result in fp0 12300 fmov.x FP_SCR0(%a6),%fp0 # perform the move 12307 fabs.x %fp0,%fp1 # make a copy of result 12332 fmov.x SRC(%a0),%fp0 # do fmove in 12358 # fp0 = result # 12442 fdiv.x FP_SCR0(%a6),%fp0 # perform divide 12460 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 12480 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 12509 fmovm.x (%a0),&0x80 # return default result in fp0 12541 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 12554 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 12572 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 12625 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 12632 fabs.x %fp0,%fp1 # make a copy of result 12739 fmov.s &0x80000000,%fp0 # load a -ZERO 12743 fmov.s &0x00000000,%fp0 # load a +ZERO 12759 fmov.s &0xff800000,%fp0 # make result -INF 12763 fmov.s &0x7f800000,%fp0 # make result +INF 12780 fmovm.x DST(%a1),&0x80 # return result in fp0 12781 fabs.x %fp0 # clear sign bit 12782 fneg.x %fp0 # set sign bit 12787 fmovm.x DST(%a1),&0x80 # return result in fp0 12788 fabs.x %fp0 # return positive INF 12811 # fp0 = result # 12862 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 12883 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 12936 fneg.x FP_SCR0(%a6),%fp0 # perform negation 12954 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 12994 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 13026 fneg.x FP_SCR0(%a6),%fp0 # perform negation 13050 fmovm.x (%a0),&0x80 # return default result in fp0 13080 fneg.x FP_SCR0(%a6),%fp0 # perform negation 13087 fabs.x %fp0,%fp1 # make a copy of result 13112 fneg.x SRC_EX(%a0),%fp0 # do fneg 13215 # fp0 = result # 13243 fint.x SRC(%a0),%fp0 # execute fint 13287 fmov.s &0x00000000,%fp0 # return +ZERO in fp0 13291 fmov.s &0x80000000,%fp0 # return -ZERO in fp0 13299 fmovm.x SRC(%a0),&0x80 # return result in fp0 13321 # fp0 = result # 13346 fintrz.x SRC(%a0),%fp0 # execute fintrz 13389 fmov.s &0x00000000,%fp0 # return +ZERO in fp0 13393 fmov.s &0x80000000,%fp0 # return -ZERO in fp0 13401 fmovm.x SRC(%a0),&0x80 # return result in fp0 13429 # fp0 = result # 13482 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 13501 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 13554 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 13572 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 13609 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 13641 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 13665 fmovm.x (%a0),&0x80 # return default result in fp0 13695 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 13702 fabs.x %fp0,%fp1 # make a copy of result 13722 fabs.x SRC(%a0),%fp0 # force absolute value 13770 fcmp.x %fp0,SRC(%a0) # do compare 13943 # fp0 = result # 13999 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 14017 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 14026 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 14049 fmovm.x (%a0),&0x80 # return default result in fp0 14075 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 14082 fabs.x %fp0,%fp1 # make a copy of result 14097 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 14115 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 14152 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 14159 fabs.x %fp0,%fp1 # make a copy of result 14284 # fp0 = result # 14346 fsgldiv.x FP_SCR0(%a6),%fp0 # perform sgl divide 14364 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 14373 fsgldiv.x FP_SCR0(%a6),%fp0 # execute divide 14402 fmovm.x (%a0),&0x80 # return default result in fp0 14430 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide 14448 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 14488 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide 14495 fabs.x %fp0,%fp1 # make a copy of result 14622 # fp0 = result # 14669 fadd.x FP_SCR0(%a6),%fp0 # execute add 14702 fmovm.x (%sp)+,&0x80 # return result in fp0 14708 # fmov.s &0x00000000,%fp0 # return zero in fp0 14735 fmovm.x (%a0),&0x80 # return default result in fp0 14762 fadd.x FP_SCR0(%a6),%fp0 # execute add 14780 fadd.x FP_SCR0(%a6),%fp0 # execute add 14798 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 14880 fabs.x %fp0 # compare absolute values 14882 fcmp.x %fp0,%fp1 # is first result > second? 14970 fmov.s &0x00000000,%fp0 # return +ZERO 14984 fmov.s &0x00000000,%fp0 # return +ZERO 14989 fmov.s &0x80000000,%fp0 # return -ZERO 15075 # fp0 = result # 15122 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 15155 fmovm.x (%sp)+,&0x80 # return result in fp0 15161 # fmov.s &0x00000000,%fp0 # return zero in fp0 15188 fmovm.x (%a0),&0x80 # return default result in fp0 15215 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 15233 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 15251 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 15333 fabs.x %fp0 # compare absolute values 15335 fcmp.x %fp0,%fp1 # is first result > second? 15422 fmov.s &0x00000000,%fp0 # no; return +ZERO 15436 fmov.s &0x00000000,%fp0 # no; return +ZERO 15441 fmov.s &0x80000000,%fp0 # return -ZERO 15484 fneg.x %fp0 # invert sign 15518 # fp0 = result # 15564 fsqrt.x (%a0),%fp0 # execute square root 15617 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute 15635 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 15672 fsqrt.x FP_SCR0(%a6),%fp0 # execute square root 15691 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 15723 fsqrt.x FP_SCR0(%a6),%fp0 # perform square root 15747 fmovm.x (%a0),&0x80 # return default result in fp0 15780 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute 15787 fmov.x %fp0,%fp1 # make a copy of result 15820 fmov.s &0x00000000,%fp0 # return +ZERO 15824 fmov.s &0x80000000,%fp0 # return -ZERO 15832 fmovm.x SRC(%a0),&0x80 # return +INF in fp0 16154 # fp0 = default result # 16227 # fp0 = default operand error result # 19725 fmov.l %d0, %fp0 # load a long 19738 fmov.w %d0, %fp0 # load a word 19751 fmov.b %d0, %fp0 # load a byte 19779 fmov.s (%a0), %fp0 # no, so can load it regular 19815 # load a LONG into %fp0: # 19819 # (3) fmov.l into %fp0 # 19834 fmov.l %d0, %fp0 # read into %fp0;convert to xprec 19851 # load a WORD into %fp0: # 19855 # (3) fmov.w into %fp0 # 19870 fmov.w %d0, %fp0 # read into %fp0;convert to xprec 19887 # load a BYTE into %fp0: # 19891 # (3) fmov.b into %fp0 # 19906 fmov.b %d0, %fp0 # read into %fp0;convert to xprec 19923 # load a SGL into %fp0: # 19927 # (3) fmov.s into %fp0 # 19953 fmov.s L_SCR1(%a6), %fp0 # read into %fp0;convert to xprec 20005 # load a DBL into %fp0: # 20009 # (3) fmov.d into %fp0 # 20036 fmov.d L_SCR1(%a6), %fp0 # read into %fp0;convert to xprec 20094 # load a Xprec into %fp0: # 20098 # (3) fmov.x into %fp0 # 20126 # load a packed into %fp0: # 20130 # (3) fmov.x into %fp0 # 20172 # fp0 : intermediate underflow or overflow result if # 20231 fmov.b %fp0,%d0 # exec move out w/ correct rnd mode 20259 fmov.s %d1,%fp0 20277 fmov.w %fp0,%d0 # exec move out w/ correct rnd mode 20305 fmov.s %d1,%fp0 20323 fmov.l %fp0,%d0 # exec move out w/ correct rnd mode 20352 fmov.s %d1,%fp0 20463 fmov.s %fp0,%d0 # store does convert and round 20566 fmov.s %fp0,%d0 # store to single 20610 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded 20613 fabs.x %fp0 # need absolute value 20614 fcmp.b %fp0,&0x2 # did exponent increase? 20701 fmov.d %fp0,L_SCR1(%a6) # store does convert and round 20787 fmov.d %fp0,L_SCR1(%a6) # store to double 20821 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded 20824 fabs.x %fp0 # need absolute value 20825 fcmp.b %fp0,&0x2 # did exponent increase? 21612 # fp0 = extended precision value to store # 21619 # Store the value in fp0 to the FP register designated by the # 22995 # a0 to extended-precision value in fp0. # 23001 # fp0 = exact fp representation of the packed bcd value. # 23126 # 1. Calculate absolute value of mantissa in fp0 by mul and add. 23140 # (*) fp0: mantissa accumulator 23146 fmov.s &0x00000000,%fp0 # accumulator 23154 fadd.b %d0,%fp0 # add digit to sum in fp0 23164 fmul.s &0x41200000,%fp0 # fp0 = fp0 * 10 23166 fadd.b %d0,%fp0 # fp0 = fp0 + digit 23181 # Check the sign of the mant and make the value in fp0 the same sign. 23186 fneg.x %fp0 # if set, negate fp0 23289 fmul.x %fp1,%fp0 # mul mantissa by 10**(no_bits_shifted) 23337 fdiv.x %fp1,%fp0 # div mantissa by 10**(no_bits_shifted) 23423 # Check the sign of the adjusted exp and make the value in fp0 the 23424 # same sign. If the exp was pos then multiply fp1*fp0; 23425 # else divide fp0/fp1. 23430 # (*) fp0: mantissa accumulator 23437 fdiv.x %fp1,%fp0 # exp is negative, so divide mant by exp 23440 fmul.x %fp1,%fp0 # exp is positive, so multiply by exp 23443 # Clean up and return with result in fp0. 23536 # is in fp0. # 23602 # fp0: scratch 23613 fmovm.x &0x7,-(%sp) # {%fp0-%fp2} 23682 # fp0: x/float(ILOG) 23697 fmov.x FP_SCR1(%a6),%fp0 # now fp0 has 1.f 23699 fadd.w %d0,%fp0 # add in exp 23700 fsub.s FONE(%pc),%fp0 # subtract off 1.0 23702 fmul.x PLOG2UP1(%pc),%fp0 # if neg, mul by LOG2UP1 23703 fmov.l %fp0,%d6 # put ILOG in d6 as a lword 23706 fmul.x PLOG2(%pc),%fp0 # if pos, mul by LOG2 23707 fmov.l %fp0,%d6 # put ILOG in d6 as a lword 23744 # fp0: float(ILOG)/Unchanged 23816 # fp0: float(ILOG)/Unchanged 23919 # fp0: float(ILOG)/X adjusted for SCALE (Y) 23928 fmov.x (%a0),%fp0 # load X from memory 23929 fabs.x %fp0 # use abs(X) 23932 fdiv.x %fp1,%fp0 # calculate X / SCALE -> Y to fp0 23940 # fp0 = input_op * 10^ISCALE * 10^24 23965 fmovm.x (%sp)+,&0x80 # load normalized DENORM into fp0 23966 fmul.x (%sp)+,%fp0 23968 # fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8 23969 # fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16 23976 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^8 23977 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^16 23986 fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8 23987 fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16 23989 fmul.x %fp1,%fp0 # calculate X * SCALE -> Y to fp0 24007 # fp0: Y/Y with lsb adjusted 24013 fmov.x %fp0,FP_SCR1(%a6) # move Y to memory 24018 fmov.x FP_SCR1(%a6),%fp0 # write adjusted Y back to fpu 24034 # The FPSP routine sintd0 is used. The output is in fp0. 24049 # fp0: Y/YINT 24063 fmov.x %fp0,(%a0) # move Y to memory at FP_SCR1(a6) 24069 # bsr sintdo # sint routine returns int in fp0 24076 fint.x FP_SCR1(%a6),%fp0 # do fint() 24116 # fp0: int portion of Y/abs(YINT) adjusted 24149 fabs.x %fp0 # take abs of YINT 24155 fabs.x %fp0 # take abs of YINT 24156 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^(LEN-1) 24165 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^LEN 24168 fdiv.s FTEN(%pc),%fp0 # if equal, divide by 10 24194 fabs.x %fp0 # get abs(YINT) 24195 fcmp.x %fp0,%fp2 # check if abs(YINT) = 10^LEN 24197 fdiv.s FTEN(%pc),%fp0 # divide abs(YINT) by 10 24225 # fp0: int portion of Y/abs(YINT) adjusted 24235 fdiv.x %fp2,%fp0 # divide abs(YINT) by 10^LEN 24237 fmov.x %fp0,(%a0) # move abs(YINT)/10^LEN to memory 24297 # fp0: abs(YINT) adjusted/float(ILOG) 24308 ftest.x %fp0 # test for zero 24310 fmov.l %d6,%fp0 # float ILOG 24311 fabs.x %fp0 # get abs of ILOG 24316 fmov.s F4933(%pc),%fp0 # force exponent to 4933 24319 fmov.l %d6,%fp0 # float ILOG 24320 fabs.x %fp0 # get abs of ILOG 24323 ftest.x %fp0 # test for zero 24325 fmov.s FONE(%pc),%fp0 # force exponent to 1 24328 fmov.l %d6,%fp0 # float ILOG 24329 fabs.x %fp0 # get abs of ILOG 24331 fdiv.x 24(%a1),%fp0 # compute ILOG/10^4 24332 fmov.x %fp0,FP_SCR1(%a6) # store fp0 in memory 24377 # fp0: float(ILOG)/Unchanged 24401 fmovm.x (%sp)+,&0xe0 # {%fp0-%fp2} 24576 # Clean up and return with result in fp0. 24691 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
|
H A D | ftest.S | 254 fsin.x DATA(%a6),%fp0 294 ftan.x DATA(%a6),%fp0 331 fmovcr.x &0x31,%fp0 482 fmov.b &0x2,%fp0 486 fmul.x &0xc00000008000000000000000,%fp0 522 fabs.p &0xc12300012345678912345678,%fp0 673 fmov.b &0x1,%fp0 727 fmov.b &0x1,%fp0 739 fmov.x %fp0,-(%sp) 746 fmov.s &0x7f800000,%fp0 783 fmov.b &0x1,%fp0 842 fmov.b &0x2,%fp0 849 fmul.x DATA(%a6),%fp0 894 fmov.b &0x2,%fp0 901 fmul.x DATA(%a6),%fp0 953 fdiv.b &0x2,%fp0 1004 fdiv.b &0x2,%fp0 1055 fadd.b &0x2,%fp0 1106 fadd.b &0x2,%fp0 1157 fadd.s &0x7f800000,%fp0 1208 fdiv.b &0x0,%fp0 1255 fmov.b &0x2,%fp0 1258 fmul.x DATA(%a6),%fp0 1296 fmov.l &0x7fffffff,%fp0 1300 fmul.x DATA(%a6),%fp0 1341 fabs.p DATA(%a6),%fp0
|
H A D | pfpsp.S | 326 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0 646 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 714 # the operation has been emulated. the result is in fp0. 730 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 745 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 764 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 803 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 886 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 980 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 989 # in fp1 (don't forget to save fp0). what to do now? 1007 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1038 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1077 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 1211 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 1337 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1404 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1569 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1586 # the extended precision result is still in fp0. but, we need to save it 1589 # for fp0/fp1 which have already been restored. that way, we can write 1593 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1676 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1691 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1708 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1737 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1754 # the extended precision result is still in fp0. but, we need to save it 1761 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1789 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1889 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1907 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 1988 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2019 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2120 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2138 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2188 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2228 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2268 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1 2467 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 2636 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 2696 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 2778 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2795 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2808 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1 2897 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3019 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack 3046 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack 3114 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3138 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3310 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3334 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3531 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3602 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3626 fmov.l FP_SRC_HI(%a6),%fp0 # load integer src 3627 fmov.x %fp0,FP_SRC(%a6) # store integer as extended precision 3685 # the operation has been emulated. the result is in fp0. 3691 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 3776 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack 3796 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 5700 # fp0 = default result # 5773 # fp0 = default operand error result # 7073 # fp0 : intermediate underflow or overflow result if # 7132 fmov.b %fp0,%d0 # exec move out w/ correct rnd mode 7160 fmov.s %d1,%fp0 7178 fmov.w %fp0,%d0 # exec move out w/ correct rnd mode 7206 fmov.s %d1,%fp0 7224 fmov.l %fp0,%d0 # exec move out w/ correct rnd mode 7253 fmov.s %d1,%fp0 7364 fmov.s %fp0,%d0 # store does convert and round 7467 fmov.s %fp0,%d0 # store to single 7511 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded 7514 fabs.x %fp0 # need absolute value 7515 fcmp.b %fp0,&0x2 # did exponent increase? 7602 fmov.d %fp0,L_SCR1(%a6) # store does convert and round 7688 fmov.d %fp0,L_SCR1(%a6) # store to double 7722 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded 7725 fabs.x %fp0 # need absolute value 7726 fcmp.b %fp0,&0x2 # did exponent increase? 7972 # fp0 = result # 8059 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8077 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 8085 # - calculate the default result and return it in fp0. 8099 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8121 fmovm.x (%a0),&0x80 # return default result in fp0 8159 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8169 # - calculate the default result and return it in fp0. 8177 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8184 fabs.x %fp0,%fp1 # make a copy of result 8196 # - calculate the default result and return it in fp0. 8215 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8233 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 8288 fmul.x FP_SCR0(%a6),%fp0 # execute multiply 8295 fabs.x %fp0,%fp1 # make a copy of result 8406 fmov.s &0x80000000,%fp0 # load -ZERO 8410 fmov.s &0x00000000,%fp0 # load +ZERO 8424 fmovm.x DST(%a1),&0x80 # return INF result in fp0 8430 fabs.x %fp0 # clear result sign 8431 fneg.x %fp0 # set result sign 8435 fabs.x %fp0 # clear result sign 8441 fmovm.x SRC(%a0),&0x80 # return INF result in fp0 8467 # fp0 = result # 8516 fmovm.x SRC(%a0),&0x80 # return result in fp0 8532 fmovm.x SRC(%a0),&0x80 # return result in fp0 8587 fmov.x FP_SCR0(%a6),%fp0 # perform move 8605 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 8645 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 8677 fmov.x FP_SCR0(%a6),%fp0 # perform move 8701 fmovm.x (%a0),&0x80 # return default result in fp0 8731 fmov.x FP_SCR0(%a6),%fp0 # perform the move 8738 fabs.x %fp0,%fp1 # make a copy of result 8763 fmov.x SRC(%a0),%fp0 # do fmove in 8789 # fp0 = result # 8873 fdiv.x FP_SCR0(%a6),%fp0 # perform divide 8891 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 8911 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 8940 fmovm.x (%a0),&0x80 # return default result in fp0 8972 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 8985 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 9003 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 9056 fdiv.x FP_SCR0(%a6),%fp0 # execute divide 9063 fabs.x %fp0,%fp1 # make a copy of result 9170 fmov.s &0x80000000,%fp0 # load a -ZERO 9174 fmov.s &0x00000000,%fp0 # load a +ZERO 9190 fmov.s &0xff800000,%fp0 # make result -INF 9194 fmov.s &0x7f800000,%fp0 # make result +INF 9211 fmovm.x DST(%a1),&0x80 # return result in fp0 9212 fabs.x %fp0 # clear sign bit 9213 fneg.x %fp0 # set sign bit 9218 fmovm.x DST(%a1),&0x80 # return result in fp0 9219 fabs.x %fp0 # return positive INF 9242 # fp0 = result # 9293 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 9314 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 9367 fneg.x FP_SCR0(%a6),%fp0 # perform negation 9385 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 9425 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 9457 fneg.x FP_SCR0(%a6),%fp0 # perform negation 9481 fmovm.x (%a0),&0x80 # return default result in fp0 9511 fneg.x FP_SCR0(%a6),%fp0 # perform negation 9518 fabs.x %fp0,%fp1 # make a copy of result 9543 fneg.x SRC_EX(%a0),%fp0 # do fneg 9646 # fp0 = result # 9674 fint.x SRC(%a0),%fp0 # execute fint 9718 fmov.s &0x00000000,%fp0 # return +ZERO in fp0 9722 fmov.s &0x80000000,%fp0 # return -ZERO in fp0 9730 fmovm.x SRC(%a0),&0x80 # return result in fp0 9752 # fp0 = result # 9777 fintrz.x SRC(%a0),%fp0 # execute fintrz 9820 fmov.s &0x00000000,%fp0 # return +ZERO in fp0 9824 fmov.s &0x80000000,%fp0 # return -ZERO in fp0 9832 fmovm.x SRC(%a0),&0x80 # return result in fp0 9860 # fp0 = result # 9913 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 9932 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 9985 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 10003 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 10040 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 10072 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 10096 fmovm.x (%a0),&0x80 # return default result in fp0 10126 fabs.x FP_SCR0(%a6),%fp0 # perform absolute 10133 fabs.x %fp0,%fp1 # make a copy of result 10153 fabs.x SRC(%a0),%fp0 # force absolute value 10201 fcmp.x %fp0,SRC(%a0) # do compare 10374 # fp0 = result # 10430 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 10448 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 10457 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 10480 fmovm.x (%a0),&0x80 # return default result in fp0 10506 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 10513 fabs.x %fp0,%fp1 # make a copy of result 10528 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 10546 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 10583 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply 10590 fabs.x %fp0,%fp1 # make a copy of result 10715 # fp0 = result # 10777 fsgldiv.x FP_SCR0(%a6),%fp0 # perform sgl divide 10795 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 10804 fsgldiv.x FP_SCR0(%a6),%fp0 # execute divide 10833 fmovm.x (%a0),&0x80 # return default result in fp0 10861 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide 10879 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 10919 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide 10926 fabs.x %fp0,%fp1 # make a copy of result 11053 # fp0 = result # 11100 fadd.x FP_SCR0(%a6),%fp0 # execute add 11133 fmovm.x (%sp)+,&0x80 # return result in fp0 11139 # fmov.s &0x00000000,%fp0 # return zero in fp0 11166 fmovm.x (%a0),&0x80 # return default result in fp0 11193 fadd.x FP_SCR0(%a6),%fp0 # execute add 11211 fadd.x FP_SCR0(%a6),%fp0 # execute add 11229 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 11311 fabs.x %fp0 # compare absolute values 11313 fcmp.x %fp0,%fp1 # is first result > second? 11401 fmov.s &0x00000000,%fp0 # return +ZERO 11415 fmov.s &0x00000000,%fp0 # return +ZERO 11420 fmov.s &0x80000000,%fp0 # return -ZERO 11506 # fp0 = result # 11553 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 11586 fmovm.x (%sp)+,&0x80 # return result in fp0 11592 # fmov.s &0x00000000,%fp0 # return zero in fp0 11619 fmovm.x (%a0),&0x80 # return default result in fp0 11646 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 11664 fsub.x FP_SCR0(%a6),%fp0 # execute subtract 11682 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 11764 fabs.x %fp0 # compare absolute values 11766 fcmp.x %fp0,%fp1 # is first result > second? 11853 fmov.s &0x00000000,%fp0 # no; return +ZERO 11867 fmov.s &0x00000000,%fp0 # no; return +ZERO 11872 fmov.s &0x80000000,%fp0 # return -ZERO 11915 fneg.x %fp0 # invert sign 11949 # fp0 = result # 11995 fsqrt.x (%a0),%fp0 # execute square root 12048 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute 12066 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0 12103 fsqrt.x FP_SCR0(%a6),%fp0 # execute square root 12122 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0 12154 fsqrt.x FP_SCR0(%a6),%fp0 # perform square root 12178 fmovm.x (%a0),&0x80 # return default result in fp0 12211 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute 12218 fmov.x %fp0,%fp1 # make a copy of result 12251 fmov.s &0x00000000,%fp0 # return +ZERO 12255 fmov.s &0x80000000,%fp0 # return -ZERO 12263 fmovm.x SRC(%a0),&0x80 # return +INF in fp0 12828 # fp0 = extended precision value to store # 12835 # Store the value in fp0 to the FP register designated by the # 12955 # a0 to extended-precision value in fp0. # 12961 # fp0 = exact fp representation of the packed bcd value. # 13086 # 1. Calculate absolute value of mantissa in fp0 by mul and add. 13100 # (*) fp0: mantissa accumulator 13106 fmov.s &0x00000000,%fp0 # accumulator 13114 fadd.b %d0,%fp0 # add digit to sum in fp0 13124 fmul.s &0x41200000,%fp0 # fp0 = fp0 * 10 13126 fadd.b %d0,%fp0 # fp0 = fp0 + digit 13141 # Check the sign of the mant and make the value in fp0 the same sign. 13146 fneg.x %fp0 # if set, negate fp0 13249 fmul.x %fp1,%fp0 # mul mantissa by 10**(no_bits_shifted) 13297 fdiv.x %fp1,%fp0 # div mantissa by 10**(no_bits_shifted) 13383 # Check the sign of the adjusted exp and make the value in fp0 the 13384 # same sign. If the exp was pos then multiply fp1*fp0; 13385 # else divide fp0/fp1. 13390 # (*) fp0: mantissa accumulator 13397 fdiv.x %fp1,%fp0 # exp is negative, so divide mant by exp 13400 fmul.x %fp1,%fp0 # exp is positive, so multiply by exp 13403 # Clean up and return with result in fp0. 13496 # is in fp0. # 13562 # fp0: scratch 13573 fmovm.x &0x7,-(%sp) # {%fp0-%fp2} 13642 # fp0: x/float(ILOG) 13657 fmov.x FP_SCR1(%a6),%fp0 # now fp0 has 1.f 13659 fadd.w %d0,%fp0 # add in exp 13660 fsub.s FONE(%pc),%fp0 # subtract off 1.0 13662 fmul.x PLOG2UP1(%pc),%fp0 # if neg, mul by LOG2UP1 13663 fmov.l %fp0,%d6 # put ILOG in d6 as a lword 13666 fmul.x PLOG2(%pc),%fp0 # if pos, mul by LOG2 13667 fmov.l %fp0,%d6 # put ILOG in d6 as a lword 13704 # fp0: float(ILOG)/Unchanged 13776 # fp0: float(ILOG)/Unchanged 13879 # fp0: float(ILOG)/X adjusted for SCALE (Y) 13888 fmov.x (%a0),%fp0 # load X from memory 13889 fabs.x %fp0 # use abs(X) 13892 fdiv.x %fp1,%fp0 # calculate X / SCALE -> Y to fp0 13900 # fp0 = input_op * 10^ISCALE * 10^24 13925 fmovm.x (%sp)+,&0x80 # load normalized DENORM into fp0 13926 fmul.x (%sp)+,%fp0 13928 # fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8 13929 # fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16 13936 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^8 13937 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^16 13946 fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8 13947 fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16 13949 fmul.x %fp1,%fp0 # calculate X * SCALE -> Y to fp0 13967 # fp0: Y/Y with lsb adjusted 13973 fmov.x %fp0,FP_SCR1(%a6) # move Y to memory 13978 fmov.x FP_SCR1(%a6),%fp0 # write adjusted Y back to fpu 13994 # The FPSP routine sintd0 is used. The output is in fp0. 14009 # fp0: Y/YINT 14023 fmov.x %fp0,(%a0) # move Y to memory at FP_SCR1(a6) 14029 # bsr sintdo # sint routine returns int in fp0 14036 fint.x FP_SCR1(%a6),%fp0 # do fint() 14076 # fp0: int portion of Y/abs(YINT) adjusted 14109 fabs.x %fp0 # take abs of YINT 14115 fabs.x %fp0 # take abs of YINT 14116 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^(LEN-1) 14125 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^LEN 14128 fdiv.s FTEN(%pc),%fp0 # if equal, divide by 10 14154 fabs.x %fp0 # get abs(YINT) 14155 fcmp.x %fp0,%fp2 # check if abs(YINT) = 10^LEN 14157 fdiv.s FTEN(%pc),%fp0 # divide abs(YINT) by 10 14185 # fp0: int portion of Y/abs(YINT) adjusted 14195 fdiv.x %fp2,%fp0 # divide abs(YINT) by 10^LEN 14197 fmov.x %fp0,(%a0) # move abs(YINT)/10^LEN to memory 14257 # fp0: abs(YINT) adjusted/float(ILOG) 14268 ftest.x %fp0 # test for zero 14270 fmov.l %d6,%fp0 # float ILOG 14271 fabs.x %fp0 # get abs of ILOG 14276 fmov.s F4933(%pc),%fp0 # force exponent to 4933 14279 fmov.l %d6,%fp0 # float ILOG 14280 fabs.x %fp0 # get abs of ILOG 14283 ftest.x %fp0 # test for zero 14285 fmov.s FONE(%pc),%fp0 # force exponent to 1 14288 fmov.l %d6,%fp0 # float ILOG 14289 fabs.x %fp0 # get abs of ILOG 14291 fdiv.x 24(%a1),%fp0 # compute ILOG/10^4 14292 fmov.x %fp0,FP_SCR1(%a6) # store fp0 in memory 14337 # fp0: float(ILOG)/Unchanged 14361 fmovm.x (%sp)+,&0xe0 # {%fp0-%fp2} 14536 # Clean up and return with result in fp0. 14651 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
|
/linux-4.4.14/arch/sh/kernel/cpu/sh5/ |
H A D | fpu.c | 21 asm volatile("fst.p %0, (0*8), fp0\n\t" save_fpu() 63 asm volatile("fld.p %0, (0*8), fp0\n\t" restore_fpu()
|
/linux-4.4.14/drivers/gpu/drm/gma500/ |
H A D | mdfld_device.c | 198 pipe->fp0 = PSB_RVDC32(map->fp0); mdfld_save_display_registers() 286 PSB_WVDC32(pipe->fp0, map->fp0); mdfld_restore_display_registers() 302 PSB_WVDC32(pipe->fp0, map->fp0); mdfld_restore_display_registers() 449 .fp0 = MRST_FPA0, 472 .fp0 = MDFLD_DPLL_DIV0, 494 .fp0 = MRST_FPA0, /* This is what the old code did ?? */
|
H A D | oaktrail_device.c | 210 p->fp0 = PSB_RVDC32(MRST_FPA0); oaktrail_save_display_registers() 325 PSB_WVDC32(p->fp0, MRST_FPA0); oaktrail_restore_display_registers() 465 .fp0 = MRST_FPA0, 489 .fp0 = FPB0,
|
H A D | psb_intel_display.c | 224 REG_WRITE(map->fp0, fp); psb_intel_crtc_mode_set() 259 REG_WRITE(map->fp0, fp); psb_intel_crtc_mode_set() 324 fp = REG_READ(map->fp0); psb_intel_crtc_clock_get() 333 fp = p->fp0; psb_intel_crtc_clock_get()
|
H A D | psb_device.c | 264 .fp0 = FPA0, 288 .fp0 = FPB0,
|
H A D | gma_display.c | 573 crtc_state->saveFP0 = REG_READ(map->fp0); gma_crtc_save() 620 REG_WRITE(map->fp0, crtc_state->saveFP0); gma_crtc_restore() 621 REG_READ(map->fp0); gma_crtc_restore()
|
H A D | cdv_device.c | 526 .fp0 = FPA0, 551 .fp0 = FPB0,
|
H A D | oaktrail_crtc.c | 562 REG_WRITE_WITH_AUX(map->fp0, fp, i); oaktrail_crtc_mode_set() 571 REG_WRITE_WITH_AUX(map->fp0, fp, i); oaktrail_crtc_mode_set()
|
H A D | psb_drv.h | 278 u32 fp0; member in struct:psb_offset 312 u32 fp0; member in struct:psb_pipe
|
H A D | cdv_intel_display.c | 865 fp = REG_READ(map->fp0); cdv_intel_crtc_clock_get() 873 fp = p->fp0; cdv_intel_crtc_clock_get()
|
H A D | mdfld_intel_display.c | 940 REG_WRITE(map->fp0, 0); mdfld_crtc_mode_set() 992 REG_WRITE(map->fp0, fp); mdfld_crtc_mode_set()
|
/linux-4.4.14/arch/m68k/kernel/ |
H A D | process.c | 177 asm volatile ("fmovemd %/fp0-%/fp7,%0\n\t" copy_thread() 188 asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t" copy_thread() 234 "fmovemd %/fp0-%/fp7,%3" dump_fpu() 246 asm volatile ("fmovemx %/fp0-%/fp7,%0" dump_fpu()
|
H A D | signal.c | 315 __asm__ volatile ("fmovemd %0,%%fp0-%%fp1\n\t" restore_fpu_state() 326 "fmovemx %0,%%fp0-%%fp1\n\t" restore_fpu_state() 406 __asm__ volatile ("fmovemd %0,%%fp0-%%fp7\n\t" rt_restore_fpu_state() 417 "fmovemx %0,%%fp0-%%fp7\n\t" rt_restore_fpu_state() 477 __asm__ volatile ("fmovemd %%fp0-%%fp1,%0\n\t" save_fpu_state() 489 "fmovemx %%fp0-%%fp1,%0\n\t" save_fpu_state() 539 __asm__ volatile ("fmovemd %%fp0-%%fp7,%0\n\t" rt_save_fpu_state() 551 "fmovemx %%fp0-%%fp7,%0\n\t" rt_save_fpu_state()
|
H A D | entry.S | 365 2: fmovemx %fp0-%fp7,%a0@(TASK_THREAD+THREAD_FPREG) 397 2: fmovemx %a1@(TASK_THREAD+THREAD_FPREG),%fp0-%fp7
|
/linux-4.4.14/drivers/video/fbdev/intelfb/ |
H A D | intelfbhw.c | 1048 u32 *dpll, *fp0, *fp1; intelfbhw_mode_to_hw() local 1064 fp0 = &hw->fpb0; intelfbhw_mode_to_hw() 1076 fp0 = &hw->fpa0; intelfbhw_mode_to_hw() 1146 *fp0 = (n << FP_N_DIVISOR_SHIFT) | intelfbhw_mode_to_hw() 1149 *fp1 = *fp0; intelfbhw_mode_to_hw() 1284 const u32 *dpll, *fp0, *fp1, *pipe_conf; intelfbhw_program_mode() local 1307 fp0 = &hw->fpb0; intelfbhw_program_mode() 1331 fp0 = &hw->fpa0; intelfbhw_program_mode() 1406 OUTREG(fp0_reg, *fp0); intelfbhw_program_mode()
|
/linux-4.4.14/arch/m68k/include/asm/ |
H A D | user.h | 32 unsigned long fpregs[8*3]; /* fp0-fp7 registers */
|
/linux-4.4.14/drivers/gpu/drm/i915/ |
H A D | intel_display.c | 6203 I915_WRITE(FP0(crtc->pipe), crtc->config->dpll_hw_state.fp0); i9xx_set_pll_dividers() 7189 crtc_state->dpll_hw_state.fp0 = fp; i9xx_update_pll_dividers() 8200 pipe_config->dpll_hw_state.fp0 = I915_READ(FP0(crtc->pipe)); i9xx_get_pipe_config() 8955 crtc_state->dpll_hw_state.fp0 = fp; ironlake_crtc_compute_clock() 10556 fp = pipe_config->dpll_hw_state.fp0; i9xx_crtc_clock_get() 10699 pipe_config.dpll_hw_state.fp0 = I915_READ(FP0(pipe)); intel_crtc_mode_get() 12091 "fp0: 0x%x, fp1: 0x%x\n", intel_dump_pipe_config() 12094 pipe_config->dpll_hw_state.fp0, intel_dump_pipe_config() 12611 PIPE_CONF_CHECK_X(dpll_hw_state.fp0); intel_pipe_config_compare() 13349 hw_state->fp0 = I915_READ(PCH_FP0(pll->id)); ibx_pch_dpll_get_hw_state() 13358 I915_WRITE(PCH_FP0(pll->id), pll->config.hw_state.fp0); ibx_pch_dpll_mode_set()
|
H A D | i915_debugfs.c | 3090 seq_printf(m, " fp0: 0x%08x\n", pll->config.hw_state.fp0); i915_shared_dplls_info()
|
H A D | i915_drv.h | 368 uint32_t fp0; member in struct:intel_dpll_hw_state
|