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