| /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
|