Lines Matching refs:FP1
337 set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1
656 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
725 # the EXOP, if an exception occurred, is in fp1.
740 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
749 # in fp1. now, simply jump to _real_ovfl()!
751 fmovm.x &0x40,FP_SRC(%a6) # save EXOP (fp1) to stack
755 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
769 fmovm.x &0x40,FP_SRC(%a6) # save EXOP (fp1) to stack
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?
1013 fmovm.x &0x40,FP_SRC(%a6) # save EXOP (fp1) to stack
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
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
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
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 fp1
4440 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
4989 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
5025 # fp1 = cos(X) #
5141 #--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
5163 fmov.x %fp0,%fp1
5164 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5168 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER
5206 fmov.x %fp0,%fp1
5207 fmul.x %fp1,%fp1 # FP1 IS T
5214 fmul.x %fp1,%fp3 # TA7
5215 fmul.x %fp1,%fp2 # TA6
5220 fmul.x %fp1,%fp3 # T(A5+TA7)
5221 fmul.x %fp1,%fp2 # T(A4+TA6)
5226 fmul.x %fp3,%fp1 # T(A3+T(A5+TA7))
5229 fadd.x SINA1(%pc),%fp1 # A1+T(A3+T(A5+TA7))
5232 fadd.x %fp2,%fp1 # [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
5234 fmul.x %fp1,%fp0 # SIN(R')-R'
5259 fmov.x %fp0,%fp1
5260 fmul.x %fp1,%fp1 # FP1 IS T
5267 fmul.x %fp1,%fp2 # TB8
5272 fmul.x %fp1,%fp3 # TB7
5280 fmul.x %fp1,%fp2 # T(B6+TB8)
5281 fmul.x %fp1,%fp3 # T(B5+TB7)
5286 fmul.x %fp1,%fp2 # T(B4+T(B6+TB8))
5287 fmul.x %fp3,%fp1 # T(B3+T(B5+TB7))
5290 fadd.s COSB1(%pc),%fp1 # B1+T(B3+T(B5+TB7))
5294 fadd.x %fp1,%fp0
5374 fmov.x %fp0,%fp1
5376 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5380 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER
5403 fmov.d SINA7(%pc),%fp1 # A7
5405 fmul.x %fp0,%fp1 # SA7
5415 fadd.d SINA6(%pc),%fp1 # A6+SA7
5418 fmul.x %fp0,%fp1 # S(A6+SA7)
5427 fadd.d SINA5(%pc),%fp1 # A5+S(A6+SA7)
5430 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7))
5434 fadd.d SINA4(%pc),%fp1 # A4+S(A5+S(A6+SA7))
5438 fmul.x %fp0,%fp1 # S(A4+...)
5441 fadd.d SINA3(%pc),%fp1 # A3+S(A4+...)
5444 fmul.x %fp0,%fp1 # S(A3+...)
5447 fadd.x SINA2(%pc),%fp1 # A2+S(A3+...)
5450 fmul.x %fp0,%fp1 # S(A2+...)
5453 fadd.x SINA1(%pc),%fp1 # A1+S(A2+...)
5456 fmul.x %fp0,%fp1 # S(A1+...)
5459 fmul.x RPRIME(%a6),%fp1 # R'S(A1+...)
5466 fadd.x RPRIME(%a6),%fp1 # COS(X)
5478 fmov.d COSB8(%pc),%fp1 # B8
5481 fmul.x %fp0,%fp1 # SB8
5488 fadd.d COSB7(%pc),%fp1 # B7+SB8
5494 fmul.x %fp0,%fp1 # S(B7+SB8)
5501 fadd.d COSB6(%pc),%fp1 # B6+S(B7+SB8)
5504 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8))
5507 fadd.d COSB5(%pc),%fp1 # B5+S(B6+S(B7+SB8))
5510 fmul.x %fp0,%fp1 # S(B5+...)
5513 fadd.d COSB4(%pc),%fp1 # B4+S(B5+...)
5516 fmul.x %fp0,%fp1 # S(B4+...)
5519 fadd.x COSB3(%pc),%fp1 # B3+S(B4+...)
5522 fmul.x %fp0,%fp1 # S(B3+...)
5525 fadd.x COSB2(%pc),%fp1 # B2+S(B3+...)
5528 fmul.x %fp0,%fp1 # S(B2+...)
5532 fadd.s COSB1(%pc),%fp1 # B1+S(B2...)
5534 fmul.x SPRIME(%a6),%fp1 # S'(B1+S(B2+...))
5539 fadd.s POSNEG1(%a6),%fp1 # COS(X)
5554 fmov.s &0x3F800000,%fp1
5557 fsub.s &0x00800000,%fp1
5570 fmov.s &0x3F800000,%fp1
5583 fmov.s &0x00000000,%fp1 # fp1 = 0
5609 fmov.x %fp0,%fp1 # save high result in fp1
5611 fsub.x %fp0,%fp1 # determine low component of result
5612 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
5616 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5660 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED
5696 fsub.x %fp4,%fp1 # fp1 = a := r - p
5700 fadd.x %fp1,%fp0 # fp0 = R := A+a
5707 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a
5892 fmov.x %fp0,%fp1
5893 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5897 fmov.l %fp1,%d1 # CONVERT TO INTEGER
5915 fmov.x %fp0,%fp1
5916 fmul.x %fp1,%fp1 # S = R*R
5921 fmul.x %fp1,%fp3 # SQ4
5922 fmul.x %fp1,%fp2 # SP3
5927 fmul.x %fp1,%fp3 # S(Q3+SQ4)
5928 fmul.x %fp1,%fp2 # S(P2+SP3)
5933 fmul.x %fp1,%fp3 # S(Q2+S(Q3+SQ4))
5934 fmul.x %fp1,%fp2 # S(P1+S(P2+SP3))
5939 fmul.x %fp3,%fp1 # S(Q1+S(Q2+S(Q3+SQ4)))
5943 fadd.s &0x3F800000,%fp1 # 1+S(Q1+...)
5948 fdiv.x %fp1,%fp0 # last inst - possible exception set
5952 fmov.x %fp0,%fp1
5974 fmul.x %fp1,%fp2 # RS(P1+S(P2+SP3))
5978 fadd.x %fp2,%fp1 # R+RS(P1+S(P2+SP3))
5983 fmov.x %fp1,-(%sp)
6014 fmov.s &0x00000000,%fp1 # fp1 = 0
6040 fmov.x %fp0,%fp1 # save high result in fp1
6042 fsub.x %fp0,%fp1 # determine low component of result
6043 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
6047 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
6091 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED
6127 fsub.x %fp4,%fp1 # fp1 = a := r - p
6131 fadd.x %fp1,%fp0 # fp0 = R := A+a
6138 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a
6400 fmov.x %fp0,%fp1 # FP1 IS X
6401 fmul.x X(%a6),%fp1 # FP1 IS X*F, NOTE THAT X*F > 0
6403 fadd.s &0x3F800000,%fp1 # FP1 IS 1 + X*F
6404 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F)
6441 fmov.x %fp0,%fp1
6442 fmul.x %fp1,%fp1
6444 fadd.x %fp1,%fp2 # A3+V
6445 fmul.x %fp1,%fp2 # V*(A3+V)
6446 fmul.x %fp0,%fp1 # U*V
6448 fmul.d ATANA1(%pc),%fp1 # A1*U*V
6449 fmul.x %fp2,%fp1 # A1*U*V*(A2+V*(A3+V))
6450 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED
6459 #--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
6479 fmov.x %fp0,%fp1
6480 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y
6485 fmul.x %fp1,%fp2 # Z*B6
6486 fmul.x %fp1,%fp3 # Z*B5
6491 fmul.x %fp1,%fp2 # Z*(B4+Z*B6)
6492 fmul.x %fp3,%fp1 # Z*(B3+Z*B5)
6495 fadd.d ATANB1(%pc),%fp1 # B1+Z*(B3+Z*B5)
6500 fadd.x %fp2,%fp1 # [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
6502 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6532 fmov.s &0xBF800000,%fp1 # LOAD -1
6533 fdiv.x %fp0,%fp1 # FP1 IS -1/X
6537 fmov.x %fp1,%fp0 # FP0 IS X'
6539 fmov.x %fp1,X(%a6) # X IS REALLY X'
6541 fmov.x %fp0,%fp1
6542 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y
6547 fmul.x %fp1,%fp3 # Z*C5
6548 fmul.x %fp1,%fp2 # Z*B4
6553 fmul.x %fp3,%fp1 # Z*(C3+Z*C5), FP3 RELEASED
6556 fadd.d ATANC1(%pc),%fp1 # C1+Z*(C3+Z*C5)
6559 fadd.x %fp2,%fp1 # [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
6561 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)]
6659 fmov.s &0x3F800000,%fp1
6660 fsub.x %fp0,%fp1 # 1-X
6664 fmul.x %fp2,%fp1 # (1+X)(1-X)
6666 fsqrt.x %fp1 # SQRT([1-X][1+X])
6667 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X])
6752 fmov.s &0x3F800000,%fp1
6753 fadd.x %fp0,%fp1 # 1+X
6756 fdiv.x %fp1,%fp0 # (1-X)/(1+X)
7238 fmov.x %fp0,%fp1
7257 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7262 fadd.x %fp1,%fp0 # X + N*L1
7271 fmov.x %fp0,%fp1
7272 fmul.x %fp1,%fp1 # fp1 IS S = R*R
7276 fmul.x %fp1,%fp2 # fp2 IS S*A5
7277 fmov.x %fp1,%fp3
7283 fmul.x %fp1,%fp2 # fp2 IS S*(A3+S*A5)
7288 fmul.x %fp1,%fp3 # fp3 IS S*(A2+S*A4)
7293 fmul.x %fp1,%fp2 # fp2 IS S*(A1+S*(A3+S*A5))
7296 fmov.x (%a1)+,%fp1 # fp1 is lead. pt. of 2^(J/64)
7303 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1)
7307 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*...
7335 fmov.x %fp0,%fp1
7403 fmov.x %fp0,%fp1
7419 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7424 fadd.x %fp1,%fp0 # X + N*L1
7434 fmov.x %fp0,%fp1
7435 fmul.x %fp1,%fp1 # fp1 IS S = R*R
7439 fmul.x %fp1,%fp2 # fp2 IS S*A6
7440 fmov.x %fp1,%fp3
7449 fmul.x %fp1,%fp2 # fp2 IS S*(A4+S*A6)
7452 fmul.x %fp1,%fp3 # fp3 IS S*(A3+S*A5)
7457 fmul.x %fp1,%fp2 # fp2 IS S*(A2+S*(A4+S*A6))
7462 fmul.x %fp3,%fp1 # fp1 IS S*(A1+S*(A3+S*A5))
7465 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5))
7482 fmov.s 12(%a1),%fp1 # fp1 is t
7483 fadd.x ONEBYSC(%a6),%fp1 # fp1 is t+OnebySc
7484 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released
7499 fmov.x (%a1)+,%fp1 # fp1 is T
7501 fadd.x ONEBYSC(%a6),%fp1 # fp1 is T+OnebySc
7502 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t)
7547 fmov.s &0x2F30CAA8,%fp1 # fp1 is B12
7548 fmul.x %fp0,%fp1 # fp1 is S*B12
7550 fadd.s &0x32D73220,%fp1 # fp1 is B10+S*B12
7553 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ...
7556 fadd.d EM1B8(%pc),%fp1 # fp1 is B8+S*...
7559 fmul.x %fp0,%fp1 # fp1 is S*(B8+...
7562 fadd.d EM1B6(%pc),%fp1 # fp1 is B6+S*...
7565 fmul.x %fp0,%fp1 # fp1 is S*(B6+...
7568 fadd.d EM1B4(%pc),%fp1 # fp1 is B4+S*...
7571 fmul.x %fp0,%fp1 # fp1 is S*(B4+...
7574 fadd.x EM1B2(%pc),%fp1 # fp1 is B2+S*...
7577 fmul.x %fp0,%fp1 # fp1 is S*(B2+...
7580 fmul.x (%a0),%fp1 # fp1 is X*S*(B2...
7583 fadd.x %fp2,%fp1 # fp1 is Q
7587 fadd.x %fp1,%fp0 # fp0 is S*B1+Q
7752 fmov.s &0x3E800000,%fp1 # (1/4)
7753 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|))
7757 fadd.x %fp1,%fp0
7865 fmov.x %fp0,%fp1
7866 fadd.s &0x3F800000,%fp1 # 1+Z
7868 fdiv.x %fp1,%fp0 # Z/(1+Z)
7998 fmov.x %fp0,%fp1
7999 fadd.s &0x40000000,%fp1 # Z+2
8001 fmov.x %fp1,V(%a6)
8039 fmov.s %d1,%fp1 # -SIGN(X)*2 IN SGL FMT
8040 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ]
8048 fadd.x %fp1,%fp0
8369 fmov.l %d1,%fp1 # CONVERT K TO FLOATING-POINT FORMAT
8388 #--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
8389 #--REGISTERS SAVED: FPCR, FP1, FP2
8394 fmul.x LOGOF2(%pc),%fp1 # GET K*LOG2 WHILE FP0 IS NOT READY
8397 fmov.x %fp1,KLOG2(%a6) # PUT K*LOG2 IN MEMORY, FREE FP1
8404 fmov.x %fp2,%fp1
8406 fmul.d LOGA6(%pc),%fp1 # V*A6
8409 fadd.d LOGA4(%pc),%fp1 # A4+V*A6
8412 fmul.x %fp3,%fp1 # V*(A4+V*A6)
8415 fadd.d LOGA2(%pc),%fp1 # A2+V*(A4+V*A6)
8418 fmul.x %fp3,%fp1 # V*(A2+V*(A4+V*A6))
8422 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6))
8425 fadd.x (%a0),%fp1 # LOG(F)+U*V*(A2+V*(A4+V*A6))
8427 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U)
8442 #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8443 fmov.x %fp0,%fp1
8444 fsub.s one(%pc),%fp1 # FP1 IS X-1
8446 fadd.x %fp1,%fp1 # FP1 IS 2(X-1)
8448 #--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8452 fdiv.x %fp0,%fp1 # FP1 IS U
8454 #--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
8458 fmov.x %fp1,%fp0
8460 fmov.x %fp1,SAVEU(%a6) # STORE U IN MEMORY, FREE FP1
8461 fmov.x %fp0,%fp1
8462 fmul.x %fp1,%fp1 # FP1 IS W
8467 fmul.x %fp1,%fp3 # W*B5
8468 fmul.x %fp1,%fp2 # W*B4
8473 fmul.x %fp3,%fp1 # W*(B3+W*B5), FP3 RELEASED
8477 fadd.d LOGB1(%pc),%fp1 # B1+W*(B3+W*B5)
8480 fadd.x %fp2,%fp1 # B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
8483 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
8569 fmov.x %fp0,%fp1 # FP1 IS INPUT Z
8594 fadd.x %fp1,%fp1 # FP1 IS 2Z
8596 #--U = FP1/FP0
8606 #--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
8625 fadd.x %fp1,%fp1 # GET 2Z
8627 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z
8630 fmov.s negone(%pc),%fp1 # FP1 IS K = -1
8643 fadd.x %fp1,%fp0 # FP0 IS Y-F
8647 fmov.s zero(%pc),%fp1 # FP1 IS K = 0
8726 fmov.x %fp0,%fp1
8727 fneg.x %fp1 # -Y
8729 fadd.s &0x3F800000,%fp1 # 1-Y
8730 fdiv.x %fp1,%fp0 # 2Y/(1-Y)
9120 fmov.x %fp0,%fp1
9121 fmul.s &0x42800000,%fp1 # 64 * X
9122 fmov.l %fp1,INT(%a6) # N = ROUND-TO-INT(64 X)
9125 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT
9140 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9144 fmul.s &0x3C800000,%fp1 # (1/64)*N
9150 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X)
9217 fmov.x %fp0,%fp1
9218 fmul.d L2TEN64(%pc),%fp1 # X*64*LOG10/LOG2
9219 fmov.l %fp1,INT(%a6) # N=INT(X*64*LOG10/LOG2)
9222 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT
9237 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9240 fmov.x %fp1,%fp2
9242 fmul.d L10TWO1(%pc),%fp1 # N*(LOG2/64LOG10)_LEAD
9249 fsub.x %fp1,%fp0 # X - N L_LEAD
9268 fmov.x %fp0,%fp1
9269 fmul.x %fp1,%fp1 # FP1 IS S = R*R
9274 fmul.x %fp1,%fp2 # FP2 IS S*A5
9275 fmul.x %fp1,%fp3 # FP3 IS S*A4
9280 fmul.x %fp1,%fp2 # FP2 IS S*(A3+S*A5)
9281 fmul.x %fp1,%fp3 # FP3 IS S*(A2+S*A4)
9286 fmul.x %fp1,%fp2 # FP2 IS S*(A1+S*(A3+S*A5))
10219 # and return the result in fp1.
10231 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
10254 fmov.s &0x00000000,%fp1 # return EXOP in fp1
10266 fmov.s &0x0000000,%fp1 # return EXOP in fp1
10333 fmov.s &0x00000000,%fp1 # return EXOP in fp1
10346 fmov.s &0x00000000,%fp1 # return EXOP in fp1
10654 fmov.s &0x3f800000,%fp1
10672 fmov.x qnan(%pc),%fp1 # load NAN
10682 fmov.x LOCAL_EX(%a0),%fp1
10692 fmov.x LOCAL_EX(%a0),%fp1
10699 # sto_cos(): store fp1 to the fpreg designated by the CMDREG dst field. #
10700 # fp1 holds the result of the cosine portion of ssincos(). #
10701 # the value in fp1 will not take any exceptions when moved. #
10703 # fp1 : fp value to store #
10731 fmov.x %fp1,%fp2
10734 fmov.x %fp1,%fp3
10737 fmov.x %fp1,%fp4
10740 fmov.x %fp1,%fp5
10743 fmov.x %fp1,%fp6
10746 fmov.x %fp1,%fp7
11358 # fp1 = EXOP #
11551 # fp1 = EXOP (if exception occurred) #
11727 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
11762 fabs.x %fp0,%fp1 # make a copy of result
11763 fcmp.b %fp1,&0x2 # is |result| >= 2.b?
11831 fmul.x FP_SCR0(%a6),%fp1 # execute multiply
11847 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
11873 fabs.x %fp0,%fp1 # make a copy of result
11874 fcmp.b %fp1
11894 fmul.x FP_SCR0(%a6),%fp1 # execute multiply
11897 fabs.x %fp1 # make absolute value
11898 fcmp.b %fp1,&0x2 # is |result| < 2.b?
12046 # fp1 = EXOP (if exception occurred) #
12133 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
12244 fmovm.x FP_SCR1(%a6),&0x40 # return EXOP in fp1
12299 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
12316 fabs.x %fp0,%fp1 # make a copy of result
12317 fcmp.b %fp1,&0x2 # is |result| >= 2.b?
12368 # fp1 = EXOP (if exception occurred) #
12540 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
12599 fdiv.x FP_SCR0(%a6),%fp1 # execute divide
12615 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
12641 fabs.x %fp0,%fp1 # make a copy of result
12642 fcmp.b %fp1,&0x1 # is |result| > 1.b?
12653 fmovm.x FP_SCR1(%a6),&0x40 # load dst op into fp1
12662 fdiv.x FP_SCR0(%a6),%fp1 # execute divide
12665 fabs.x %fp1 # make absolute value
12666 fcmp.b %fp1,&0x1 # is |result| < 1.b?
12821 # fp1 = EXOP (if exception occurred) #
12913 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
13024 fmovm.x FP_SCR1(%a6),&0x40 # return EXOP in fp1
13078 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
13096 fabs.x %fp0,%fp1 # make a copy of result
13097 fcmp.b %fp1,&0x2 # is |result| >= 2.b?
13439 # fp1 = EXOP (if exception occurred) #
13531 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
13639 fmovm.x FP_SCR1(%a6),&0x40 # return EXOP in fp1
13693 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
13711 fabs.x %fp0,%fp1 # make a copy of result
13712 fcmp.b %fp1,&0x2 # is |result| >= 2.b?
13953 # fp1 = EXOP (if exception occurred) #
14075 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
14091 fabs.x %fp0,%fp1 # make a copy of result
14092 fcmp.b %fp1,&0x2 # is |result| >= 2.b?
14136 fsglmul.x FP_SCR0(%a6),%fp1 # execute sgl multiply
14152 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
14168 fabs.x %fp0,%fp1 # make a copy of result
14169 fcmp.b %fp1,&0x2 # is |result| > 2.b?
14180 fmovm.x FP_SCR1(%a6),&0x40 # load dst op into fp1
14189 fsglmul.x FP_SCR0(%a6),%fp1 # execute sgl multiply
14192 fabs.x %fp1 # make absolute value
14193 fcmp.b %fp1,&0x2 # is |result| < 2.b?
14294 # fp1 = EXOP (if exception occurred) #
14428 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
14469 fsgldiv.x FP_SCR0(%a6),%fp1 # execute sgl divide
14485 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
14504 fabs.x %fp0,%fp1 # make a copy of result
14505 fcmp.b %fp1,&0x1 # is |result| > 1.b?
14516 fmovm.x FP_SCR1(%a6),&0x40 # load dst op into %fp1
14524 fsgldiv.x FP_SCR0(%a6),%fp1 # execute sgl divide
14527 fabs.x %fp1 # make absolute value
14528 fcmp.b %fp1,&0x1 # is |result| < 1.b?
14632 # fp1 = EXOP (if exception occurred) #
14761 fmovm.x (%sp)+,&0x40 # return EXOP in fp1
14823 fadd.x FP_SCR0(%a6),%fp1 # execute multiply
14837 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
14877 fmovm.x FP_SCR1(%a6),&0x40 # load dst op into fp1
14885 fadd.x FP_SCR0(%a6),%fp1 # execute add
14890 fabs.x %fp1
14891 fcmp.x %fp0,%fp1 # is first result > second?
15085 # fp1 = EXOP (if exception occurred) #
15214 fmovm.x (%sp)+,&0x40 # return EXOP in fp1
15276 fsub.x FP_SCR0(%a6),%fp1 # execute subtract
15290 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
15330 fmovm.x FP_SCR1(%a6),&0x40 # load dst op into fp1
15338 fsub.x FP_SCR0(%a6),%fp1 # execute subtract
15343 fabs.x %fp1
15344 fcmp.x %fp0,%fp1 # is first result > second?
15528 # fp1 = EXOP (if exception occurred) #
15721 fmovm.x FP_SCR1(%a6),&0x40 # return EXOP in fp1
15775 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
15796 fmov.x %fp0,%fp1 # make a copy of result
15797 fcmp.b %fp1,&0x1 # is |result| >= 1.b?
18293 lsl.b &0x1,%d1 # should FP1 be moved?
18388 lsl.b &0x1,%d1 # should FP1 be moved?
20432 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
20674 fmovm.x FP_SCR0(%a6),&0x40 # return EXOP in fp1
23043 # A4. Calculate the factor 10^exp in FP1 using a table of #
23051 # mantissa in FP0 by the factor in FP1 if the adjusted #
23052 # exponent sign is positive, and dividing FP0 by FP1 if #
23088 fmovm.x &0x1,-(%sp) # save fp1
23288 fmov.s &0x3f800000,%fp1 # init fp1 to 1
23292 bcc.b ap_p_en # if 1, mul fp1 by pwrten factor
23293 fmul.x (%a1,%d3),%fp1 # mul by 10**(d3_bit_no)
23298 fmul.x %fp1,%fp0 # mul mantissa by 10**(no_bits_shifted)
23336 fmov.s &0x3f800000,%fp1 # init fp1 to 1
23340 bcc.b ap_n_en # if 1, mul fp1 by pwrten factor
23341 fmul.x (%a1,%d3),%fp1 # mul by 10**(d3_bit_no)
23346 fdiv.x %fp1,%fp0 # div mantissa by 10**(no_bits_shifted)
23366 # (*) fp1: power-of-ten accumulator
23421 fmov.s &0x3f800000,%fp1 # init fp1 to 1
23425 fmul.x (%a1,%d3),%fp1 # mul by 10**(d3_bit_no)
23433 # same sign. If the exp was pos then multiply fp1*fp0;
23434 # else divide fp0/fp1.
23440 # ( ) fp1: scaling factor - 10**(abs(exp))
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
23464 fmovm.x (%sp)+,&0x40 # restore fp1
23518 # sign of ISCALE, used in A9. Fp1 contains #
23612 # fp1: scratch
23692 # fp1: x/x
23754 # fp1: x/x
23788 # of ISCALE, used in A9. Fp1 contains 10^^(abs(ISCALE)) using
23826 # fp1: x/10^ISCALE
23856 fmov.s FONE(%pc),%fp1 # init fp1 to 1
23886 fmul.x (%a1,%d3),%fp1 # mul by 10**(d3_bit_no)
23929 # fp1: 10^ISCALE/Unchanged
23941 fdiv.x %fp1,%fp0 # calculate X / SCALE -> Y to fp0
23998 fmul.x %fp1,%fp0 # calculate X * SCALE -> Y to fp0
24017 # fp1: 10^ISCALE/Unchanged
24059 # fp1: 10^ISCALE/Unchanged
24126 # fp1: 10^ISCALE/Unchanged
24235 # fp1: 10^ISCALE/Unchanged
24307 # fp1: 10^ISCALE/Unchanged
24387 # fp1: 10^ISCALE/Unchanged
24700 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
Indexes created Thu Oct 23 18:09:57 GMT 2025