Lines Matching refs:fp0
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