Lines Matching refs:FP0
336 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0
656 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
724 # the operation has been emulated. the result is in fp0.
740 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
755 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
774 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
813 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
896 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
990 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
999 # in fp1 (don't forget to save fp0). what to do now?
1017 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1048 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1087 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
1221 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
1347 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1414 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1579 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1596 # the extended precision result is still in fp0. but, we need to save it
1599 # for fp0/fp1 which have already been restored. that way, we can write
1603 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1686 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1701 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1718 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1747 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1764 # the extended precision result is still in fp0. but, we need to save it
1771 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1799 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1899 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1917 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
1998 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2029 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2130 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2148 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2198 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2238 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2278 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0/fp1
2477 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
2646 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
2706 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
2788 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2805 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2818 fmovm.x EXC_FP0(%a6),&0xc0 # restore fp0-fp1
2907 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3029 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack
3056 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1 on stack
3124 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3148 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3320 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3344 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3541 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3612 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3636 fmov.l FP_SRC_HI(%a6),%fp0 # load integer src
3637 fmov.x %fp0,FP_SRC(%a6) # store integer as extended precision
3695 # the operation has been emulated. the result is in fp0.
3701 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
3786 fmovm.x &0xc0,EXC_FPREGS(%a6) # save fp0-fp1 on stack
3806 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
4312 # operations and postincrement mode. (bit7 = FP7 ... bit0 = FP0)
4335 tst.b %d1 # should FP0 be moved?
4430 tst.b %d1 # should FP0 be moved?
5710 # fp0 = default result #
5783 # fp0 = default operand error result #
7083 # fp0 : intermediate underflow or overflow result if #
7142 fmov.b %fp0,%d0 # exec move out w/ correct rnd mode
7170 fmov.s %d1,%fp0
7188 fmov.w %fp0,%d0 # exec move out w/ correct rnd mode
7216 fmov.s %d1,%fp0
7234 fmov.l %fp0,%d0 # exec move out w/ correct rnd mode
7263 fmov.s %d1,%fp0
7374 fmov.s %fp0,%d0 # store does convert and round
7477 fmov.s %fp0,%d0 # store to single
7521 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded
7524 fabs.x %fp0 # need absolute value
7525 fcmp.b %fp0,&0x2 # did exponent increase?
7612 fmov.d %fp0,L_SCR1(%a6) # store does convert and round
7698 fmov.d %fp0,L_SCR1(%a6) # store to double
7732 fmov.x FP_SCR0(%a6),%fp0 # force fop to be rounded
7735 fabs.x %fp0 # need absolute value
7736 fcmp.b %fp0,&0x2 # did exponent increase?
7982 # fp0 = result #
8069 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8087 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
8095 # - calculate the default result and return it in fp0.
8109 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8131 fmovm.x (%a0),&0x80 # return default result in fp0
8169 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8179 # - calculate the default result and return it in fp0.
8187 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8194 fabs.x %fp0,%fp1 # make a copy of result
8206 # - calculate the default result and return it in fp0.
8225 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8243 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
8298 fmul.x FP_SCR0(%a6),%fp0 # execute multiply
8305 fabs.x %fp0,%fp1 # make a copy of result
8416 fmov.s &0x80000000,%fp0 # load -ZERO
8420 fmov.s &0x00000000,%fp0 # load +ZERO
8434 fmovm.x DST(%a1),&0x80 # return INF result in fp0
8440 fabs.x %fp0 # clear result sign
8441 fneg.x %fp0 # set result sign
8445 fabs.x %fp0 # clear result sign
8451 fmovm.x SRC(%a0),&0x80 # return INF result in fp0
8477 # fp0 = result #
8526 fmovm.x SRC(%a0),&0x80 # return result in fp0
8542 fmovm.x SRC(%a0),&0x80 # return result in fp0
8597 fmov.x FP_SCR0(%a6),%fp0 # perform move
8615 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
8655 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
8687 fmov.x FP_SCR0(%a6),%fp0 # perform move
8711 fmovm.x (%a0),&0x80 # return default result in fp0
8741 fmov.x FP_SCR0(%a6),%fp0 # perform the move
8748 fabs.x %fp0,%fp1 # make a copy of result
8773 fmov.x SRC(%a0),%fp0 # do fmove in
8799 # fp0 = result #
8883 fdiv.x FP_SCR0(%a6),%fp0 # perform divide
8901 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
8921 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
8950 fmovm.x (%a0),&0x80 # return default result in fp0
8982 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
8995 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
9013 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
9066 fdiv.x FP_SCR0(%a6),%fp0 # execute divide
9073 fabs.x %fp0,%fp1 # make a copy of result
9180 fmov.s &0x80000000,%fp0 # load a -ZERO
9184 fmov.s &0x00000000,%fp0 # load a +ZERO
9200 fmov.s &0xff800000,%fp0 # make result -INF
9204 fmov.s &0x7f800000,%fp0 # make result +INF
9221 fmovm.x DST(%a1),&0x80 # return result in fp0
9222 fabs.x %fp0 # clear sign bit
9223 fneg.x %fp0 # set sign bit
9228 fmovm.x DST(%a1),&0x80 # return result in fp0
9229 fabs.x %fp0 # return positive INF
9252 # fp0 = result #
9303 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
9324 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
9377 fneg.x FP_SCR0(%a6),%fp0 # perform negation
9395 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
9435 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
9467 fneg.x FP_SCR0(%a6),%fp0 # perform negation
9491 fmovm.x (%a0),&0x80 # return default result in fp0
9521 fneg.x FP_SCR0(%a6),%fp0 # perform negation
9528 fabs.x %fp0,%fp1 # make a copy of result
9553 fneg.x SRC_EX(%a0),%fp0 # do fneg
9656 # fp0 = result #
9684 fint.x SRC(%a0),%fp0 # execute fint
9728 fmov.s &0x00000000,%fp0 # return +ZERO in fp0
9732 fmov.s &0x80000000,%fp0 # return -ZERO in fp0
9740 fmovm.x SRC(%a0),&0x80 # return result in fp0
9762 # fp0 = result #
9787 fintrz.x SRC(%a0),%fp0 # execute fintrz
9830 fmov.s &0x00000000,%fp0 # return +ZERO in fp0
9834 fmov.s &0x80000000,%fp0 # return -ZERO in fp0
9842 fmovm.x SRC(%a0),&0x80 # return result in fp0
9870 # fp0 = result #
9923 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
9942 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
9995 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
10013 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
10050 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
10082 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
10106 fmovm.x (%a0),&0x80 # return default result in fp0
10136 fabs.x FP_SCR0(%a6),%fp0 # perform absolute
10143 fabs.x %fp0,%fp1 # make a copy of result
10163 fabs.x SRC(%a0),%fp0 # force absolute value
10211 fcmp.x %fp0,SRC(%a0) # do compare
10384 # fp0 = result #
10440 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
10458 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
10467 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
10490 fmovm.x (%a0),&0x80 # return default result in fp0
10516 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
10523 fabs.x %fp0,%fp1 # make a copy of result
10538 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
10556 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
10593 fsglmul.x FP_SCR0(%a6),%fp0 # execute sgl multiply
10600 fabs.x %fp0,%fp1 # make a copy of result
10725 # fp0 = result #
10787 fsgldiv.x FP_SCR0(%a6),%fp0 # perform sgl divide
10805 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
10814 fsgldiv.x FP_SCR0(%a6),%fp0 # execute divide
10843 fmovm.x (%a0),&0x80 # return default result in fp0
10871 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide
10889 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
10929 fsgldiv.x FP_SCR0(%a6),%fp0 # execute sgl divide
10936 fabs.x %fp0,%fp1 # make a copy of result
11063 # fp0 = result #
11110 fadd.x FP_SCR0(%a6),%fp0 # execute add
11143 fmovm.x (%sp)+,&0x80 # return result in fp0
11149 # fmov.s &0x00000000,%fp0 # return zero in fp0
11176 fmovm.x (%a0),&0x80 # return default result in fp0
11203 fadd.x FP_SCR0(%a6),%fp0 # execute add
11221 fadd.x FP_SCR0(%a6),%fp0 # execute add
11239 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
11321 fabs.x %fp0 # compare absolute values
11323 fcmp.x %fp0,%fp1 # is first result > second?
11411 fmov.s &0x00000000,%fp0 # return +ZERO
11425 fmov.s &0x00000000,%fp0 # return +ZERO
11430 fmov.s &0x80000000,%fp0 # return -ZERO
11516 # fp0 = result #
11563 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
11596 fmovm.x (%sp)+,&0x80 # return result in fp0
11602 # fmov.s &0x00000000,%fp0 # return zero in fp0
11629 fmovm.x (%a0),&0x80 # return default result in fp0
11656 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
11674 fsub.x FP_SCR0(%a6),%fp0 # execute subtract
11692 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
11774 fabs.x %fp0 # compare absolute values
11776 fcmp.x %fp0,%fp1 # is first result > second?
11863 fmov.s &0x00000000,%fp0 # no; return +ZERO
11877 fmov.s &0x00000000,%fp0 # no; return +ZERO
11882 fmov.s &0x80000000,%fp0 # return -ZERO
11925 fneg.x %fp0 # invert sign
11959 # fp0 = result #
12005 fsqrt.x (%a0),%fp0 # execute square root
12058 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute
12076 fmovm.x FP_SCR0(%a6),&0x80 # return result in fp0
12113 fsqrt.x FP_SCR0(%a6),%fp0 # execute square root
12132 fmovm.x FP_SCR0(%a6),&0x80 # return default result in fp0
12164 fsqrt.x FP_SCR0(%a6),%fp0 # perform square root
12188 fmovm.x (%a0),&0x80 # return default result in fp0
12221 fsqrt.x FP_SCR0(%a6),%fp0 # perform absolute
12228 fmov.x %fp0,%fp1 # make a copy of result
12261 fmov.s &0x00000000,%fp0 # return +ZERO
12265 fmov.s &0x80000000,%fp0 # return -ZERO
12273 fmovm.x SRC(%a0),&0x80 # return +INF in fp0
12838 # fp0 = extended precision value to store #
12845 # Store the value in fp0 to the FP register designated by the #
12965 # a0 to extended-precision value in fp0. #
12971 # fp0 = exact fp representation of the packed bcd value. #
12985 # adds and muls in FP0. Set the sign according to SM. #
13012 # mantissa in FP0 by the factor in FP1 if the adjusted #
13013 # exponent sign is positive, and dividing FP0 by FP1 if #
13096 # 1. Calculate absolute value of mantissa in fp0 by mul and add.
13110 # (*) fp0: mantissa accumulator
13116 fmov.s &0x00000000,%fp0 # accumulator
13124 fadd.b %d0,%fp0 # add digit to sum in fp0
13134 fmul.s &0x41200000,%fp0 # fp0 = fp0 * 10
13136 fadd.b %d0,%fp0 # fp0 = fp0 + digit
13151 # Check the sign of the mant and make the value in fp0 the same sign.
13156 fneg.x %fp0 # if set, negate fp0
13259 fmul.x %fp1,%fp0 # mul mantissa by 10**(no_bits_shifted)
13307 fdiv.x %fp1,%fp0 # div mantissa by 10**(no_bits_shifted)
13393 # Check the sign of the adjusted exp and make the value in fp0 the
13394 # same sign. If the exp was pos then multiply fp1*fp0;
13395 # else divide fp0/fp1.
13400 # (*) fp0: mantissa accumulator
13407 fdiv.x %fp1,%fp0 # exp is negative, so divide mant by exp
13410 fmul.x %fp1,%fp0 # exp is positive, so multiply by exp
13413 # Clean up and return with result in fp0.
13506 # is in fp0. #
13572 # fp0: scratch
13583 fmovm.x &0x7,-(%sp) # {%fp0-%fp2}
13652 # fp0: x/float(ILOG)
13667 fmov.x FP_SCR1(%a6),%fp0 # now fp0 has 1.f
13669 fadd.w %d0,%fp0 # add in exp
13670 fsub.s FONE(%pc),%fp0 # subtract off 1.0
13672 fmul.x PLOG2UP1(%pc),%fp0 # if neg, mul by LOG2UP1
13673 fmov.l %fp0,%d6 # put ILOG in d6 as a lword
13676 fmul.x PLOG2(%pc),%fp0 # if pos, mul by LOG2
13677 fmov.l %fp0,%d6 # put ILOG in d6 as a lword
13714 # fp0: float(ILOG)/Unchanged
13786 # fp0: float(ILOG)/Unchanged
13889 # fp0: float(ILOG)/X adjusted for SCALE (Y)
13898 fmov.x (%a0),%fp0 # load X from memory
13899 fabs.x %fp0 # use abs(X)
13902 fdiv.x %fp1,%fp0 # calculate X / SCALE -> Y to fp0
13910 # fp0 = input_op * 10^ISCALE * 10^24
13935 fmovm.x (%sp)+,&0x80 # load normalized DENORM into fp0
13936 fmul.x (%sp)+,%fp0
13938 # fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8
13939 # fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16
13946 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^8
13947 fmul.x (%sp)+,%fp0 # multiply fp0 by 10^16
13956 fmul.x 36(%a1),%fp0 # multiply fp0 by 10^8
13957 fmul.x 48(%a1),%fp0 # multiply fp0 by 10^16
13959 fmul.x %fp1,%fp0 # calculate X * SCALE -> Y to fp0
13977 # fp0: Y/Y with lsb adjusted
13983 fmov.x %fp0,FP_SCR1(%a6) # move Y to memory
13988 fmov.x FP_SCR1(%a6),%fp0 # write adjusted Y back to fpu
14004 # The FPSP routine sintd0 is used. The output is in fp0.
14019 # fp0: Y/YINT
14033 fmov.x %fp0,(%a0) # move Y to memory at FP_SCR1(a6)
14039 # bsr sintdo # sint routine returns int in fp0
14046 fint.x FP_SCR1(%a6),%fp0 # do fint()
14086 # fp0: int portion of Y/abs(YINT) adjusted
14119 fabs.x %fp0 # take abs of YINT
14125 fabs.x %fp0 # take abs of YINT
14126 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^(LEN-1)
14135 fcmp.x %fp0,%fp2 # compare abs(YINT) with 10^LEN
14138 fdiv.s FTEN(%pc),%fp0 # if equal, divide by 10
14164 fabs.x %fp0 # get abs(YINT)
14165 fcmp.x %fp0,%fp2 # check if abs(YINT) = 10^LEN
14167 fdiv.s FTEN(%pc),%fp0 # divide abs(YINT) by 10
14195 # fp0: int portion of Y/abs(YINT) adjusted
14205 fdiv.x %fp2,%fp0 # divide abs(YINT) by 10^LEN
14207 fmov.x %fp0,(%a0) # move abs(YINT)/10^LEN to memory
14267 # fp0: abs(YINT) adjusted/float(ILOG)
14278 ftest.x %fp0 # test for zero
14280 fmov.l %d6,%fp0 # float ILOG
14281 fabs.x %fp0 # get abs of ILOG
14286 fmov.s F4933(%pc),%fp0 # force exponent to 4933
14289 fmov.l %d6,%fp0 # float ILOG
14290 fabs.x %fp0 # get abs of ILOG
14293 ftest.x %fp0 # test for zero
14295 fmov.s FONE(%pc),%fp0 # force exponent to 1
14298 fmov.l %d6,%fp0 # float ILOG
14299 fabs.x %fp0 # get abs of ILOG
14301 fdiv.x 24(%a1),%fp0 # compute ILOG/10^4
14302 fmov.x %fp0,FP_SCR1(%a6) # store fp0 in memory
14347 # fp0: float(ILOG)/Unchanged
14371 fmovm.x (%sp)+,&0xe0 # {%fp0-%fp2}
14546 # Clean up and return with result in fp0.
14661 fmovm.x EXC_FPREGS(%a6),&0xc0 # restore fp0-fp1
Indexes created Sat Oct 18 08:10:09 GMT 2025