Lines Matching refs:FP0
336 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0
656 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
724 # the operation has been emulated. the result is in fp0.
740 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
755 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
774 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
813 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
896 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
990 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
999 # in fp1 (don't forget to save fp0). what to do now?
1017 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1048 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1087 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1221 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
1347 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1414 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1579 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1596 # the extended precision result is still in fp0. but, we need to save it
1599 # for fp0/fp1 which have already been restored. that way, we can write
1603 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1686 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1701 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1718 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1747 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1764 # the extended precision result is still in fp0. but, we need to save it
1771 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1799 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1899 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1917 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1998 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2029 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2130 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2148 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2198 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2238 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2278 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2477 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
2646 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
2706 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
2788 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2805 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2818 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2907 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3029 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack
3056 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack
3124 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3148 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3320 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3344 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3541 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3612 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3636 fmov.l FP_SRC_HI(%a6),%fp0 # load integer src
3637 fmov.x %fp0,FP_SRC(%a6) # store integer as extended precision
3695 # the operation has been emulated. the result is in fp0.
3701 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3786 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3806 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
4032 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1
4114 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4252 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4312 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4371 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4419 fp0-fp1
4440 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4989 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
5021 # fp0 = sin(X) or cos(X) #
5024 # fp0 = sin(X) #
5143 fmov.x (%a0),%fp0 # LOAD INPUT
5144 fmov.x %fp0,X(%a6) # save input at X
5163 fmov.x %fp0,%fp1
5176 fsub.x (%a1)+,%fp0 # X-Y1
5177 fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2
5200 fmov.x %fp0,X(%a6) # X IS R
5201 fmul.x %fp0,%fp0 # FP0 IS S
5206 fmov.x %fp0,%fp1
5228 fmul.x %fp0,%fp2 # S(A2+T(A4+TA6))
5230 fmul.x X(%a6),%fp0 # R'*S
5234 fmul.x %fp1,%fp0 # SIN(R')-R'
5239 fadd.x X(%a6),%fp0 # last inst - possible exception set
5254 fmul.x %fp0,%fp0 # FP0 IS S
5259 fmov.x %fp0,%fp1
5262 fmov.x %fp0,X(%a6) # X IS S
5292 fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8)))
5294 fadd.x %fp1,%fp0
5296 fmul.x X(%a6),%fp0
5301 fadd.s POSNEG1(%a6),%fp0 # last inst - possible exception set
5325 fmov.x X(%a6),%fp0 # last inst - possible exception set
5329 fmov.s &0x3F800000,%fp0 # fp0 = 1.0
5331 fadd.s &0x80800000,%fp0 # last inst - possible exception set
5344 fmov.s &0x3F800000,%fp0 # fp0 = 1.0
5354 fmov.x (%a0),%fp0 # LOAD INPUT
5355 fmov.x %fp0,X(%a6)
5374 fmov.x %fp0,%fp1
5386 fsub.x (%a1)+,%fp0 # X-Y1
5387 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2
5401 fmov.x %fp0,RPRIME(%a6)
5402 fmul.x %fp0,%fp0 # FP0 IS S = R*R
5405 fmul.x %fp0,%fp1 # SA7
5406 fmul.x %fp0,%fp2 # SB8
5418 fmul.x %fp0,%fp1 # S(A6+SA7)
5421 fmul.x %fp0,%fp2 # S(B7+SB8)
5430 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7))
5431 fmul.x %fp0,%fp2 # S(B6+S(B7+SB8))
5432 fmov.x %fp0,SPRIME(%a6)
5438 fmul.x %fp0,%fp1 # S(A4+...)
5439 fmul.x %fp0,%fp2 # S(B5+...)
5444 fmul.x %fp0,%fp1 # S(A3+...)
5445 fmul.x %fp0,%fp2 # S(B4+...)
5450 fmul.x %fp0,%fp1 # S(A2+...)
5451 fmul.x %fp0,%fp2 # S(B3+...)
5456 fmul.x %fp0,%fp1 # S(A1+...)
5457 fmul.x %fp2,%fp0 # S(B2+...)
5460 fadd.s COSB1(%pc),%fp0 # B1+S(B2...)
5461 fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...))
5468 fadd.s POSNEG1(%a6),%fp0 # SIN(X)
5475 fmov.x %fp0,RPRIME(%a6)
5476 fmul.x %fp0,%fp0 # FP0 IS S = R*R
5481 fmul.x %fp0,%fp1 # SB8
5482 fmov.x %fp0,SPRIME(%a6)
5483 fmul.x %fp0,%fp2 # SA7
5494 fmul.x %fp0,%fp1 # S(B7+SB8)
5499 fmul.x %fp0,%fp2 # S(A6+SA7)
5504 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8))
5505 fmul.x %fp0,%fp2 # S(A5+S(A6+SA7))
5510 fmul.x %fp0,%fp1 # S(B5+...)
5511 fmul.x %fp0,%fp2 # S(A4+...)
5516 fmul.x %fp0,%fp1 # S(B4+...)
5517 fmul.x %fp0,%fp2 # S(A3+...)
5522 fmul.x %fp0,%fp1 # S(B3+...)
5523 fmul.x %fp0,%fp2 # S(A2+...)
5528 fmul.x %fp0,%fp1 # S(B2+...)
5529 fmul.x %fp2,%fp0 # s(a1+...)
5533 fmul.x RPRIME(%a6),%fp0 # R'S(A1+...)
5541 fadd.x RPRIME(%a6),%fp0 # SIN(X)
5561 fmov.x X(%a6),%fp0
5602 ftest.x %fp0 # test sign of argument
5608 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact
5609 fmov.x %fp0,%fp1 # save high result in fp1
5610 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction
5611 fsub.x %fp0,%fp1 # determine low component of result
5612 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
5614 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5616 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5618 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2
5647 fmov.x %fp0,%fp2
5692 fsub.x %fp3,%fp0 # fp0 = A := R - P
5695 fmov.x %fp0,%fp3 # fp3 = A
5700 fadd.x %fp1,%fp0 # fp0 = R := A+a
5706 fsub.x %fp0,%fp3 # fp3 = A-R
5730 # fp0 = tan(X) #
5875 fmov.x (%a0),%fp0 # LOAD INPUT
5892 fmov.x %fp0,%fp1
5902 fsub.x (%a1)+,%fp0 # X-Y1
5904 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2
5915 fmov.x %fp0,%fp1
5937 fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3))
5941 fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3))
5948 fdiv.x %fp1,%fp0 # last inst - possible exception set
5952 fmov.x %fp0,%fp1
5953 fmul.x %fp0,%fp0 # S = R*R
5958 fmul.x %fp0,%fp3 # SQ4
5959 fmul.x %fp0,%fp2 # SP3
5964 fmul.x %fp0,%fp3 # S(Q3+SQ4)
5965 fmul.x %fp0,%fp2 # S(P2+SP3)
5970 fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4))
5971 fmul.x %fp0,%fp2 # S(P1+S(P2+SP3))
5976 fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4)))
5979 fadd.s &0x3F800000,%fp0 # 1+S(Q1+...)
5987 fdiv.x (%sp)+,%fp0 # last inst - possible exception set
5997 fmov.x %fp0,-(%sp)
6000 fmov.x (%sp)+,%fp0 # last inst - posibble exception set
6033 ftest.x %fp0 # test sign of argument
6039 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact
6040 fmov.x %fp0,%fp1 # save high result in fp1
6041 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction
6042 fsub.x %fp0,%fp1 # determine low component of result
6043 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
6045 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
6047 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
6049 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2
6078 fmov.x %fp0,%fp2
6123 fsub.x %fp3,%fp0 # fp0 = A := R - P
6126 fmov.x %fp0,%fp3 # fp3 = A
6131 fadd.x %fp1,%fp0 # fp0 = R := A+a
6137 fsub.x %fp0,%fp3 # fp3 = A-R
6160 # fp0 = arctan(X) #
6357 fmov.x (%a0),%fp0 # LOAD INPUT
6361 fmov.x %fp0,X(%a6)
6400 fmov.x %fp0,%fp1 # FP1 IS X
6402 fsub.x X(%a6),%fp0 # FP0 IS X-F
6404 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F)
6431 #--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
6441 fmov.x %fp0,%fp1
6446 fmul.x %fp0,%fp1 # U*V
6450 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED
6455 fadd.x ATANF(%a6),%fp0 # ATAN(X)
6460 #--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
6477 fmul.x %fp0,%fp0 # FPO IS Y = X*X
6479 fmov.x %fp0,%fp1
6497 fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6))
6498 fmul.x X(%a6),%fp0 # X*Y
6502 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6507 fadd.x X(%a6),%fp0
6515 fmov.x X(%a6),%fp0 # last inst - possible exception set
6533 fdiv.x %fp0,%fp1 # FP1 IS -1/X
6537 fmov.x %fp1,%fp0 # FP0 IS X'
6538 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X'
6541 fmov.x %fp0,%fp1
6554 fmul.x %fp0,%fp2 # Y*(C2+Z*C4)
6557 fmul.x X(%a6),%fp0 # X'*Y
6561 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)]
6563 fadd.x X(%a6),%fp0
6572 fadd.x NPIBY2(%pc),%fp0
6576 fadd.x PPIBY2(%pc),%fp0
6585 fmov.x NPIBY2(%pc),%fp0
6587 fadd.x PTINY(%pc),%fp0
6591 fmov.x PPIBY2(%pc),%fp0
6593 fadd.x NTINY(%pc),%fp0
6610 # fp0 = arcsin(X) #
6639 fmov.x (%a0),%fp0 # LOAD INPUT
6660 fsub.x %fp0,%fp1 # 1-X
6663 fadd.x %fp0,%fp2 # 1+X
6667 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X])
6675 fabs.x %fp0 # |X|
6676 fcmp.s %fp0,&0x3F800000
6681 fmov.x PIBY2(%pc),%fp0
6687 fmul.s (%sp)+,%fp0
6694 fmov.x (%a0),%fp0 # last inst - possible exception
6711 # fp0 = arccos(X) #
6740 fmov.x (%a0),%fp0 # LOAD INPUT
6753 fadd.x %fp0,%fp1 # 1+X
6754 fneg.x %fp0 # -X
6755 fadd.s &0x3F800000,%fp0 # 1-X
6756 fdiv.x %fp1,%fp0 # (1-X)/(1+X)
6757 fsqrt.x %fp0 # SQRT((1-X)/(1+X))
6766 fadd.x %fp0,%fp0 # 2 * ATAN( STUFF )
6770 fabs.x %fp0
6771 fcmp.s %fp0,&0x3F800000
6781 fmov.x PI(%pc),%fp0 # load PI
6783 fadd.s &0x00800000,%fp0 # add a small value
6793 fmov.x PIBY2(%pc),%fp0
6807 # fp0 = exp(X) or exp(X)-1 #
7236 fmov.x (%a0),%fp0 # load input from (a0)
7238 fmov.x %fp0,%fp1
7239 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7242 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7244 fmov.l %d1,%fp0 # convert to floating-format
7257 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7259 fmov.x %fp0,%fp2
7260 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)
7262 fadd.x %fp1,%fp0 # X + N*L1
7263 fadd.x %fp2,%fp0 # fp0 is R, reduced arg.
7271 fmov.x %fp0,%fp1
7291 fmul.x %fp0
7294 fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4),
7297 fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1
7303 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1)
7305 fadd.s (%a1),%fp0 # accurate 2^(J/64)
7307 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*...
7314 fmul.x ADJSCALE(%a6),%fp0
7318 fmul.x SCALE(%a6),%fp0 # multiply 2^(M)
7325 fadd.s &0x3F800000,%fp0 # 1+X in user mode
7333 fmov.x (%a0),%fp0 # load input from (a0)
7335 fmov.x %fp0,%fp1
7336 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7339 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7341 fmov.l %d1,%fp0 # convert to floating-format
7372 fmov.s &0x3F800000,%fp0
7375 fadd.s (%sp)+,%fp0
7401 fmov.x (%a0),%fp0 # load input from (a0)
7403 fmov.x %fp0,%fp1
7404 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7406 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7408 fmov.l %d1,%fp0 # convert to floating-format
7419 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7421 fmov.x %fp0,%fp2
7422 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)
7424 fadd.x %fp1,%fp0 # X + N*L1
7425 fadd.x %fp2,%fp0 # fp0 is R, reduced arg.
7434 fmov.x %fp0,%fp1
7464 fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6))
7465 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5))
7467 fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1
7474 fmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1)
7484 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released
7485 fadd.x (%a1),%fp0 # T+(p+(t+OnebySc))
7493 fadd.s 12(%a1),%fp0 # p+t
7494 fadd.x (%a1),%fp0 # T+(p+t)
7495 fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t))
7500 fadd.s (%a1),%fp0 # fp0 is p+t
7502 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t)
7507 fmul.x SC(%a6),%fp0
7523 fmov.x (%a0),%fp0
7526 fadd.x SC(%a6),%fp0
7531 fmov.x (%a0),%fp0
7532 fmul.d TWO140(%pc),%fp0
7536 fadd.x SC(%a6),%fp0
7539 fmul.d TWON140(%pc),%fp0
7544 fmov.x (%a0),%fp0 # fp0 is X
7545 fmul.x %fp0,%fp0 # fp0 is S := X*X
7548 fmul.x %fp0,%fp1 # fp1 is S*B12
7552 fmul.x %fp0,%fp2 # fp2 is S*B11
7553 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ...
7558 fmul.x %fp0,%fp2 # fp2 is S*(B9+...
7559 fmul.x %fp0,%fp1 # fp1 is S*(B8+...
7564 fmul.x %fp0,%fp2 # fp2 is S*(B7+...
7565 fmul.x %fp0,%fp1 # fp1 is S*(B6+...
7570 fmul.x %fp0,%fp2 # fp2 is S*(B5+...
7571 fmul.x %fp0,%fp1 # fp1 is S*(B4+...
7576 fmul.x %fp0,%fp2 # fp2 is S*(B3+...
7577 fmul.x %fp0,%fp1 # fp1 is S*(B2+...
7579 fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...)
7582 fmul.s &0x3F000000,%fp0 # fp0 is S*B1
7587 fadd.x %fp1,%fp0 # fp0 is S*B1+Q
7590 fadd.x (%a0),%fp0
7599 fmov.s &0xBF800000,%fp0 # fp0 is -1
7601 fadd.s &0x00800000,%fp0 # -1 + 2^(-126)
7613 # returned as an extended precision number in fp0. #
7618 # an exponent of $3fff and is returned in fp0. The range of #
7626 # fp0 = exponent(X) or mantissa(X) #
7635 fmov.w %d0,%fp0 # return exp in fp0
7648 fmov.w %d0,%fp0 # return exp in fp0
7662 fmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0
7688 # fp0 = cosh(X) #
7730 fmov.x (%a0),%fp0 # LOAD INPUT
7741 fabs.x %fp0 # |X|
7747 bsr setox # FP0 IS EXP(|X|)
7749 fmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|)
7753 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|))
7757 fadd.x %fp1,%fp0
7764 fabs.x %fp0
7765 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)
7766 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE
7770 fmovm.x &0x01,-(%sp) # save fp0 to stack
7771 lea (%sp),%a0 # pass ptr to fp0
7773 add.l &0xc,%sp # clear fp0 from stack
7778 fmul.x TWO16380(%pc),%fp0
7787 fmov.s &0x3F800000,%fp0
7790 fadd.s &0x00800000,%fp0
7802 # fp0 = sinh(X) #
7842 fmov.x (%a0),%fp0 # LOAD INPUT
7854 fabs.x %fp0 # Y = |X|
7860 bsr setoxm1 # FP0 IS Z = EXPM1(Y)
7865 fmov.x %fp0,%fp1
7867 fmov.x %fp0,-(%sp)
7868 fdiv.x %fp1,%fp0 # Z/(1+Z)
7872 fadd.x (%sp)+,%fp0
7877 fmul.s (%sp)+,%fp0 # last fp inst - possible exceptions set
7883 fabs.x %fp0
7884 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)
7891 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE
7895 fmovm.x &0x01,-(%sp) # save fp0 on stack
7896 lea (%sp),%a0 # pass ptr to fp0
7898 add.l &0xc,%sp # clear fp0 from stack
7903 fmul.x (%sp)+,%fp0 # possible exception
7920 # fp0 = tanh(X) #
7967 fmov.x (%a0),%fp0 # LOAD INPUT
7969 fmov.x %fp0,X(%a6)
7988 fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X|
7994 bsr setoxm1 # FP0 IS Z = EXPM1(Y)
7998 fmov.x %fp0,%fp1
8005 fdiv.x V(%a6),%fp0
8026 fmov.x X(%a6),%fp0 # Y = 2|X|
8032 bsr setox # FP0 IS EXP(Y)
8036 fadd.s &0x3F800000,%fp0 # EXP(Y)+1
8040 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ]
8044 fmov.s %d1,%fp0 # SGN IN SGL FMT
8048 fadd.x %fp1,%fp0
8054 fmov.x X(%a6),%fp0 # last inst - possible exception set
8062 fmov.s %d1,%fp0
8067 fadd.s %d1,%fp0
8086 # fp0 = log(X) or log(1+X) #
8329 fmov.x (%a0),%fp0 # LOAD INPUT
8333 #--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
8383 fmov.x X(%a6),%fp0
8386 fsub.x F(%a6),%fp0 # Y-F
8387 fmovm.x &0xc,-(%sp) # SAVE FP2-3 WHILE FP0 IS NOT READY
8388 #--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
8393 fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/F
8394 fmul.x LOGOF2(%pc),%fp1 # GET K*LOG2 WHILE FP0 IS NOT READY
8395 fmov.x %fp0,%fp2
8422 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6))
8423 fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5))
8427 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U)
8430 fadd.x KLOG2(%a6),%fp0 # FINAL ADD
8439 fcmp.b %fp0,&0x1 # is it equal to one?
8442 #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8443 fmov.x %fp0,%fp1
8445 fadd.s one(%pc),%fp0 # FP0 IS X+1
8448 #--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8452 fdiv.x %fp0,%fp1 # FP1 IS U
8458 fmov.x %fp1,%fp0
8459 fmul.x %fp0,%fp0 # FP0 IS V
8461 fmov.x %fp0,%fp1
8475 fmul.x %fp0,%fp2 # V*(B2+W*B4)
8478 fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V
8483 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
8486 fadd.x SAVEU(%a6),%fp0
8497 mov.l &-100,ADJK(%a6) # INPUT = 2^(ADJK) * FP0
8527 fmov.x X(%a6),%fp0
8549 fmov.x X(%a6),%fp0
8557 fmov.x (%a0),%fp0 # LOAD INPUT
8558 fabs.x %fp0 # test magnitude
8559 fcmp.x %fp0,LTHOLD(%pc) # compare with min threshold
8563 fmov.x (%a0),%fp0 # return signed argument
8567 fmov.x (%a0),%fp0 # LOAD INPUT
8569 fmov.x %fp0,%fp1 # FP1 IS INPUT Z
8570 fadd.s one(%pc),%fp0 # X := ROUND(1+Z)
8571 fmov.x %fp0,X(%a6)
8595 fadd.s one(%pc),%fp0 # FP0 IS 1+X
8596 #--U = FP1/FP0
8607 #--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
8616 fmov.s TWO(%pc),%fp0
8619 fsub.x F(%a6),%fp0 # 2-F
8627 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z
8634 fmov.s one(%pc),%fp0
8637 fsub.x F(%a6),%fp0 # 1-F
8643 fadd.x %fp1,%fp0 # FP0 IS Y-F
8655 fmov.s negone(%pc),%fp0
8661 fmov.s zero(%pc),%fp0
8681 # fp0 = arctanh(X) #
8725 fabs.x (%a0),%fp0 # Y = |X|
8726 fmov.x %fp0,%fp1
8728 fadd.x %fp0,%fp0 # 2Y
8730 fdiv.x %fp1,%fp0 # 2Y/(1-Y)
8746 fmul.s (%sp)+,%fp0
8750 fabs.x (%a0),%fp0 # |X|
8751 fcmp.s %fp0,&0x3F800000
8771 # fp0 = log_10(X) or log_2(X) #
8854 fmov.b &0x1,%fp0
8855 fcmp.x %fp0,(%a0) # if operand == 1,
8864 fmul.x INV_L10(%pc),%fp0
8876 fmul.x INV_L10(%pc),%fp0
8898 fmov.l %d1,%fp0
8906 fmul.x INV_L2(%pc),%fp0
8921 fmul.x INV_L2(%pc),%fp0
8935 # fp0 = 2**X or 10**X #
9105 fmov.x %fp0,X(%a6)
9120 fmov.x %fp0,%fp1
9150 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X)
9156 fmul.x LOG2(%pc),%fp0 # FP0 IS R
9169 fadd.s &0x3F800000,%fp0 # RETURN 1 + X
9189 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9192 fadd.s %d1,%fp0
9202 fmov.x %fp0,X(%a6)
9217 fmov.x %fp0,%fp1
9249 fsub.x %fp1,%fp0 # X - N L_LEAD
9252 fsub.x %fp2,%fp0 # X - N L_TRAIL
9258 fmul.x LOG10(%pc),%fp0 # FP0 IS R
9265 #--FP0 IS R. THE FOLLOWING CODE COMPUTES
9268 fmov.x %fp0,%fp1
9284 fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4)
9287 fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4)
9288 fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1
9295 fmul.x FACT1(%a6),%fp0
9296 fadd.x FACT2(%a6),%fp0
9297 fadd.x FACT1(%a6),%fp0
9305 fmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENT
9313 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9316 fadd.s %d1,%fp0
9328 # fp0 = the ROM constant rounded to the user's rounding mode,prec #
9469 fmovm.x (%a0,%d1.w),&0x80 # return result in fp0
9488 fmovm.x (%a0),&0x80 # return rounded result in fp0
9582 # fp0 = scale(X,Y) #
9607 fintrz.x SRC(%a0),%fp0 # calc int of src
9608 fmov.l %fp0,%d0 # int src to d0
9663 fmovm.x DST(%a1),&0x80 # load fp0 with normalized src
9676 fmul.x (%sp)+,%fp0 # do the multiply
9701 fmov.x DST(%a1),%fp0 # simply return dest
9721 # fp0 = FREM(X,Y) or FMOD(X,Y) #
9997 fmov.x R(%a6),%fp0 # no exception
10008 fmov.x R(%a6),%fp0
10036 fsub.x Y(%a6),%fp0 # no exceptions
10044 fneg.x %fp0
10070 fmul.x Scale(%pc),%fp0 # may cause underflow
10074 # algorithm just got done playing with fp0 and expected no exceptions
10081 fmov.x %fp0,%fp0 # capture exceptions & round
10097 fmov.s &0x00000000,%fp0
10131 # fp0 = default result #
10134 # - Store properly signed INF into fp0. #
10146 fmov.s &0x7f800000,%fp0 # return +INF in fp0
10152 fmov.s &0xff800000,%fp0 # return -INF in fp0
10159 # nan bit; Store default NAN into fp0 #
10164 fmovm.x qnan(%pc),&0x80 # return default NAN in fp0
10207 fmovm.x (%a0),&0x80 # return default result in fp0
10252 fmovm.x (%a0),&0x80 # return default result in fp0
10264 fmovm.x (%a0),&0x80 # return default result in fp0
10331 fmovm.x (%a0),&0x80 # return default result in fp0
10344 fmovm.x (%a0),&0x80 # return default result in fp0
10500 fmov.s &0x00000000,%fp0 # load +0
10507 fmov.s &0x80000000,%fp0 # load -0
10533 fmov.s &0x7f800000,%fp0 # load +INF
10542 fmov.s &0xff800000,%fp0 # load -INF
10601 fmov.s &0x3f800000,%fp0 # load +1
10610 fmov.s &0xbf800000,%fp0 # load -1
10631 fmov.x ppiby2(%pc),%fp0 # load +pi/2
10640 fmov.x mpiby2(%pc),%fp0 # load -pi/2
10649 # cosine register and return a ZERO in fp0 w/ the same sign
10657 fmov.s &0x80000000,%fp0 # return sin result in fp0
10661 fmov.s &0x00000000,%fp0 # return sin result in fp0
10821 fmov.x DST(%a1),%fp0
10951 fmov.x DST(%a1),%fp0 # the fmove sets the SNAN bit
10961 fmov.x DST(%a1),%fp0 # return the non-signalling nan
10976 fmov.x SRC(%a0),%fp0 # the fmove sets the SNAN bit
10986 fmov.x SRC(%a0),%fp0 # return the non-signalling nan
11352 # fp0 = destination operand #
11357 # fp0 = result #
11387 fmovm.x &0x80,FP_DST(%a6) # dst op is in fp0
11550 # fp0 = result #
11637 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11655 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
11663 # - calculate the default result and return it in fp0.
11677 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11699 fmovm.x (%a0),&0x80 # return default result in fp0
11737 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11747 # - calculate the default result and return it in fp0.
11755 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11762 fabs.x %fp0,%fp1 # make a copy of result
11774 # - calculate the default result and return it in fp0.
11793 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11811 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
11866 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
11873 fabs.x %fp0,%fp1 # make a copy of result
11984 fmov.s &0x80000000,%fp0 # load -ZERO
11988 fmov.s &0x00000000,%fp0 # load +ZERO
12002 fmovm.x DST(%a1),&0x80 # return INF result in fp0
12008 fabs.x %fp0 # clear result sign
12009 fneg.x %fp0 # set result sign
12013 fabs.x %fp0 # clear result sign
12019 fmovm.x SRC(%a0),&0x80 # return INF result in fp0
12045 # fp0 = result #
12094 fmovm.x SRC(%a0),&0x80 # return result in fp0
12110 fmovm.x SRC(%a0),&0x80 # return result in fp0
12165 fmov.x FP_SCR0(%a6),%fp0 # perform move
12183 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
12223 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
12255 fmov.x FP_SCR0(%a6),%fp0 # perform move
12279 fmovm.x (%a0),&0x80 # return default result in fp0
12309 fmov.x FP_SCR0(%a6),%fp0 # perform the move
12316 fabs.x %fp0,%fp1 # make a copy of result
12341 fmov.x SRC(%a0),%fp0 # do fmove in
12367 # fp0 = result #
12451 fdiv.x FP_SCR0(%a6),%fp0 # perform divide
12469 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
12489 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
12518 fmovm.x (%a0),&0x80 # return default result in fp0
12550 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
12563 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
12581 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
12634 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
12641 fabs.x %fp0,%fp1 # make a copy of result
12748 fmov.s &0x80000000,%fp0 # load a -ZERO
12752 fmov.s &0x00000000,%fp0 # load a +ZERO
12768 fmov.s &0xff800000,%fp0 # make result -INF
12772 fmov.s &0x7f800000,%fp0 # make result +INF
12789 fmovm.x DST(%a1),&0x80 # return result in fp0
12790 fabs.x %fp0 # clear sign bit
12791 fneg.x %fp0 # set sign bit
12796 fmovm.x DST(%a1),&0x80 # return result in fp0
12797 fabs.x %fp0 # return positive INF
12820 # fp0 = result #
12871 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
12892 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
12945 fneg.x FP_SCR0(%a6),%fp0 # perform negation
12963 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
13003 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
13035 fneg.x FP_SCR0(%a6),%fp0 # perform negation
13059 fmovm.x (%a0),&0x80 # return default result in fp0
13089 fneg.x FP_SCR0(%a6),%fp0 # perform negation
13096 fabs.x %fp0,%fp1 # make a copy of result
13121 fneg.x SRC_EX(%a0),%fp0 # do fneg
13224 # fp0 = result #
13252 fint.x SRC(%a0),%fp0 # execute fint
13296 fmov.s &0x00000000,%fp0 # return +ZERO in fp0
13300 fmov.s &0x80000000,%fp0 # return -ZERO in fp0
13308 fmovm.x SRC(%a0),&0x80 # return result in fp0
13330 # fp0 = result #
13355 fintrz.x SRC(%a0),%fp0 # execute fintrz
13398 fmov.s &0x00000000,%fp0 # return +ZERO in fp0
13402 fmov.s &0x80000000,%fp0 # return -ZERO in fp0
13410 fmovm.x SRC(%a0),&0x80 # return result in fp0
13438 # fp0 = result #
13491 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
13510 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
13563 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
13581 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
13618 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
13650 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
13674 fmovm.x (%a0),&0x80 # return default result in fp0
13704 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
13711 fabs.x %fp0,%fp1 # make a copy of result
13731 fabs.x SRC(%a0),%fp0 # force absolute value
13779 fcmp.x %fp0,SRC(%a0) # do compare
13952 # fp0 = result #
14008 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
14026 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
14035 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
14058 fmovm.x (%a0),&0x80 # return default result in fp0
14084 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
14091 fabs.x %fp0,%fp1 # make a copy of result
14106 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
14124 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
14161 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
14168 fabs.x %fp0,%fp1 # make a copy of result
14293 # fp0 = result #
14355 fsgldiv.x FP_SCR0(%a6),%fp0 # perform sgl divide
14373 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
14382 fsgldiv.x FP_SCR0(%a6),%fp0 # execute divide
14411 fmovm.x (%a0),&0x80 # return default result in fp0
14439 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide
14457 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
14497 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide
14504 fabs.x %fp0,%fp1 # make a copy of result
14631 # fp0 = result #
14678 fadd.x FP_SCR0(%a6),%fp0 # execute add
14711 fmovm.x (%sp)+,&0x80 # return result in fp0
14717 # fmov.s &0x00000000,%fp0 # return zero in fp0
14744 fmovm.x (%a0),&0x80 # return default result in fp0
14771 fadd.x FP_SCR0(%a6),%fp0 # execute add
14789 fadd.x FP_SCR0(%a6),%fp0 # execute add
14807 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
14889 fabs.x %fp0 # compare absolute values
14891 fcmp.x %fp0,%fp1 # is first result > second?
14979 fmov.s &0x00000000,%fp0 # return +ZERO
14993 fmov.s &0x00000000,%fp0 # return +ZERO
14998 fmov.s &0x80000000,%fp0 # return -ZERO
15084 # fp0 = result #
15131 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
15164 fmovm.x (%sp)+,&0x80 # return result in fp0
15170 # fmov.s &0x00000000,%fp0 # return zero in fp0
15197 fmovm.x (%a0),&0x80 # return default result in fp0
15224 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
15242 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
15260 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
15342 fabs.x %fp0 # compare absolute values
15344 fcmp.x %fp0,%fp1 # is first result > second?
15431 fmov.s &0x00000000,%fp0 # no; return +ZERO
15445 fmov.s &0x00000000,%fp0 # no; return +ZERO
15450 fmov.s &0x80000000,%fp0 # return -ZERO
15493 fneg.x %fp0 # invert sign
15527 # fp0 = result #
15573 fsqrt.x (%a0),%fp0 # execute square root
15626 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute
15644 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
15681 fsqrt.x FP_SCR0(%a6),%fp0 # execute square root
15700 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
15732 fsqrt.x FP_SCR0(%a6),%fp0 # perform square root
15756 fmovm.x (%a0),&0x80 # return default result in fp0
15789 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute
15796 fmov.x %fp0,%fp1 # make a copy of result
15829 fmov.s &0x00000000,%fp0 # return +ZERO
15833 fmov.s &0x80000000,%fp0 # return -ZERO
15841 fmovm.x SRC(%a0),&0x80 # return +INF in fp0
16163 # fp0 = default result #
16236 # fp0 = default operand error result #
18262 # operations and postincrement mode. (bit7 = FP7 ... bit0 = FP0)
18285 tst.b %d1 # should FP0 be moved?
18380 tst.b %d1 # should FP0 be moved?
19734 fmov.l %d0, %fp0 # load a long
19747 fmov.w %d0, %fp0 # load a word
19760 fmov.b %d0, %fp0 # load a byte
19788 fmov.s (%a0), %fp0 # no, so can load it regular
19824 # load a LONG into %fp0: #
19828 # (3) fmov.l into %fp0 #
19843 fmov.l %d0, %fp0 # read into %fp0;convert to xprec
19860 # load a WORD into %fp0: #
19864 # (3) fmov.w into %fp0 #
19879 fmov.w %d0, %fp0 # read into %fp0;convert to xprec
19896 # load a BYTE into %fp0: #
19900 # (3) fmov.b into %fp0 #
19915 fmov.b %d0, %fp0 # read into %fp0;convert to xprec
19932 # load a SGL into %fp0: #
19936 # (3) fmov.s into %fp0 #
19962 fmov.s L_SCR1(%a6), %fp0 # read into %fp0;convert to xprec
20014 # load a DBL into %fp0: #
20018 # (3) fmov.d into %fp0 #
20045 fmov.d L_SCR1(%a6), %fp0 # read into %fp0;convert to xprec
20103 # load a Xprec into %fp0: #
20107 # (3) fmov.x into %fp0 #
20135 # load a packed into %fp0: #
20139 # (3) fmov.x into %fp0 #
20181 # fp0 : intermediate underflow or overflow result if #
20240 fmov.b %fp0,%d0 # exec move out w/ correct rnd mode
20268 fmov.s %d1,%fp0
20286 fmov.w %fp0,%d0 # exec move out w/ correct rnd mode
20314 fmov.s %d1,%fp0
20332 fmov.l %fp0,%d0 # exec move out w/ correct rnd mode
20361 fmov.s %d1,%fp0
20472 fmov.s %fp0,%d0 # store does convert and round
20575 fmov.s %fp0,%d0 # store to single
20619 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded
20622 fabs.x %fp0 # need absolute value
20623 fcmp.b %fp0,&0x2 # did exponent increase?
20710 fmov.d %fp0,L_SCR1(%a6) # store does convert and round
20796 fmov.d %fp0,L_SCR1(%a6) # store to double
20830 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded
20833 fabs.x %fp0 # need absolute value
20834 fcmp.b %fp0,&0x2 # did exponent increase?
21621 # fp0 = extended precision value to store #
21628 # Store the value in fp0 to the FP register designated by the #
23004 # a0 to extended-precision value in fp0. #
23010 # fp0 = exact fp representation of the packed bcd value. #
23024 # adds and muls in FP0. Set the sign according to SM. #
23051 # mantissa in FP0 by the factor in FP1 if the adjusted #
23052 # exponent sign is positive, and dividing FP0 by FP1 if #
23135 # 1. Calculate absolute value of mantissa in fp0 by mul and add.
23149 # (*) fp0: mantissa accumulator
23155 fmov.s &0x00000000,%fp0 # accumulator
23163 fadd.b %d0,%fp0 # add digit to sum in fp0
23173 fmul.s &0x41200000,%fp0 # fp0 = fp0 * 10
23175 fadd.b %d0,%fp0 # fp0 = fp0 + digit
23190 # Check the sign of the mant and make the value in fp0 the same sign.
23195 fneg.x %fp0 # if set, negate fp0
23298 fmul.x %fp1,%fp0 # mul mantissa by 10**(no_bits_shifted)
23346 fdiv.x %fp1,%fp0 # div mantissa by 10**(no_bits_shifted)
23432 # Check the sign of the adjusted exp and make the value in fp0 the
23433 # same sign. If the exp was pos then multiply fp1*fp0;
23434 # else divide fp0/fp1.
23439 # (*) fp0: mantissa accumulator
23446 fdiv.x %fp1,%fp0 # exp is negative, so divide mant by exp
23449 fmul.x %fp1,%fp0 # exp is positive, so multiply by exp
23452 # Clean up and return with result in fp0.
23545 # is in fp0. #
23611 # fp0: scratch
23622 fmovm.x &0x7,-(%sp) # {%fp0-%fp2}
23691 # fp0: x/float(ILOG)
23706 fmov.x FP_SCR1(%a6),%fp0 # now fp0 has 1.f
23708 fadd.w %d0,%fp0 # add in exp
23709 fsub.s FONE(%pc),%fp0 # subtract off 1.0
23711 fmul.x PLOG2UP1(%pc),%fp0 # if neg, mul by LOG2UP1
23712 fmov.l %fp0,%d6 # put ILOG in d6 as a lword
23715 fmul.x PLOG2(%pc),%fp0 # if pos, mul by LOG2
23716 fmov.l %fp0,%d6 # put ILOG in d6 as a lword
23753 # fp0: float(ILOG)/Unchanged
23825 # fp0: float(ILOG)/Unchanged
23928 # fp0: float(ILOG)/X adjusted for SCALE (Y)
23937 fmov.x (%a0),%fp0 # load X from memory
23938 fabs.x %fp0 # use abs(X)
23941 fdiv.x %fp1,%fp0 # calculate X / SCALE -> Y to fp0
23949 # fp0 = input_op * 10^ISCALE * 10^24
23974 fmovm.x (%sp)+,&0x80 # load normalized DENORM into fp0
23975 fmul.x (%sp)+,%fp0
23977 # fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8
23978 # fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16
23985 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^8
23986 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^16
23995 fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8
23996 fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16
23998 fmul.x %fp1,%fp0 # calculate X * SCALE -> Y to fp0
24016 # fp0: Y/Y with lsb adjusted
24022 fmov.x %fp0,FP_SCR1(%a6) # move Y to memory
24027 fmov.x FP_SCR1(%a6),%fp0 # write adjusted Y back to fpu
24043 # The FPSP routine sintd0 is used. The output is in fp0.
24058 # fp0: Y/YINT
24072 fmov.x %fp0,(%a0) # move Y to memory at FP_SCR1(a6)
24078 # bsr sintdo # sint routine returns int in fp0
24085 fint.x FP_SCR1(%a6),%fp0 # do fint()
24125 # fp0: int portion of Y/abs(YINT) adjusted
24158 fabs.x %fp0 # take abs of YINT
24164 fabs.x %fp0 # take abs of YINT
24165 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^(LEN-1)
24174 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^LEN
24177 fdiv.s FTEN(%pc),%fp0 # if equal, divide by 10
24203 fabs.x %fp0 # get abs(YINT)
24204 fcmp.x %fp0,%fp2 # check if abs(YINT) = 10^LEN
24206 fdiv.s FTEN(%pc),%fp0 # divide abs(YINT) by 10
24234 # fp0: int portion of Y/abs(YINT) adjusted
24244 fdiv.x %fp2,%fp0 # divide abs(YINT) by 10^LEN
24246 fmov.x %fp0,(%a0) # move abs(YINT)/10^LEN to memory
24306 # fp0: abs(YINT) adjusted/float(ILOG)
24317 ftest.x %fp0 # test for zero
24319 fmov.l %d6,%fp0 # float ILOG
24320 fabs.x %fp0 # get abs of ILOG
24325 fmov.s F4933(%pc),%fp0 # force exponent to 4933
24328 fmov.l %d6,%fp0 # float ILOG
24329 fabs.x %fp0 # get abs of ILOG
24332 ftest.x %fp0 # test for zero
24334 fmov.s FONE(%pc),%fp0 # force exponent to 1
24337 fmov.l %d6,%fp0 # float ILOG
24338 fabs.x %fp0 # get abs of ILOG
24340 fdiv.x 24(%a1),%fp0 # compute ILOG/10^4
24341 fmov.x %fp0,FP_SCR1(%a6) # store fp0 in memory
24386 # fp0: float(ILOG)/Unchanged
24410 fmovm.x (%sp)+,&0xe0 # {%fp0-%fp2}
24585 # Clean up and return with result in fp0.
24700 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
Indexes created Sat Oct 18 08:10:09 GMT 2025