Lines Matching refs:a
23 You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
37 # to call a given routine. The stub routine actually performs the
38 # callout. The FPSP code does a "bsr" to the stub routine. This
39 # extra layer of hierarchy adds a slight performance penalty but
961 # The `060 FPU multiplier hardware is such that if the result of a
1242 # Separate opclass three (fpn-to-mem) ops since they have a different
1268 # input is an UNNORM, then convert it to a NORM, DENORM, or ZERO.
1426 # If the input operand to this operation was opclass two and a single
1480 bne.b fso_dbl_dnrm # it's a skewed denorm
1481 tst.l LOCAL_LO(%a0) # is it a zero?
1515 # the src can ONLY be a DENORM or an UNNORM! so, don't make any big subroutine
1519 beq.b fu_out_denorm # it's a DENORM
1562 # as a special case.
1976 # as a reminder for future predicted pain and agony, we are passing in fsave the
2297 # if we're stuffing a source operand back into an fsave frame then we
2397 # - The system stack is changed to a Trace exception stack frame #
2408 # For immediate data operations, the data is read in w/ a #
2411 # word. If no FP exception should be reported ads a result of the #
2414 # signalled as a result of emulation, then an fsave state frame #
2417 # must also check if a Trace exception is pending, in which case, we #
2418 # must create a Trace exception stack frame from the current exception #
2423 # as a result of this operation emulation. A Trace exception can be #
2425 # to a Trace stack frame and an exit made through _real_trace(). #
2535 # a normal packed op.
2538 bne.b iea_op_gp_not_spec # not a zero
2540 bne.b iea_op_gp_not_spec # not a zero
2542 beq.b iea_op_setsrc # operand is a ZERO
2586 st STORE_FLG(%a6) # don't store a final result
2929 # this ain't a pretty solution, but it works:
2974 # the instruction is a fmovm.l with 2 or 3 registers.
2984 # as a by-product, will tell us how long the instruction is.
3089 # In a system where the FP Operr exception is enabled, the goal #
3171 # the operand is either an infinity or a QNAN.
3289 # _mem_write() "callout" routines that may return a failing result. #
3328 # this would be the case for opclass two operations with a source infinity or
3725 mov.b &NORM,STAG(%a6) # src is a NORM
3759 # In a system where the DZ exception is enabled, the goal is to #
3791 # this would be the case for opclass two operations with a source zero
3820 # - The system stack contains a "Line F Emulator" exception #
3827 # When a "Line F Emulator" exception occurs, there are 3 possible #
3836 # This code also must check for "fmovecr" instructions w/ a #
3838 # really be flagged as "FPU Unimplemented". (This is a "feature" on #
3857 # if the F-Line instruction is an "fmovecr" w/ a non-zero <ea>. if
4123 # this catches a problem with the case where an exception will be re-inserted
4387 # the fp unimplemented instruction exception stack frame into a bsun stack frame,
4388 # restore a bsun exception into the machine, and branch to the user
5577 #--there is a danger of unwanted overflow in first LOOP iteration. In this
5611 mov.l %d1,%a1 # save a copy of D0
6110 #--Then, we need to compute A := R-P and a := r-p
6118 fsub.x %fp4,%fp1 # fp1 = a := r - p
6120 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but
6122 fadd.x %fp1,%fp0 # fp0 = R := A+a
6129 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a
6143 # satan(): computes the arctangent of a normalized number #
6144 # satand(): computes the arctangent of a denormalized number #
6165 # significant bits of X with a bit-1 attached at the 6-th #
6168 # Step 3. Approximate arctan(u) by a polynomial poly. #
6170 # Step 4. Return arctan(F) + poly, arctan(F) is fetched from a #
6694 # sacos(): computes the inverse cosine of a normalized input #
6695 # sacosd(): computes the inverse cosine of a denormalized input #
6774 fadd.s &0x00800000,%fp0 # add a small value
7018 # Step 4. Approximate exp(R)-1 by a polynomial #
7020 # Notes: a) In order to reduce memory access, the coefficients #
7040 # zero. The reason for such a special form is that T-1, #
7041 # T-2, and T-8 will all be exact --- a property that will #
7076 # Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial #
7078 # Notes: a) In order to reduce memory access, the coefficients #
7649 # here, we build the result in a tmp location so as not to disturb the input
8118 # can be performed by a multiplication. #
8528 mov.l %d5,%d7 # a copy of D5
9626 # the multiply factor that we're trying to create should be a denorm
9651 # the src will force the dst to a DENORM value or worse. so, let's
10064 # preceding fmul was a denorm. but, it better not have been since the
10066 # as a result. trust me...
10067 # bra t_avoid_unsupp # check for denorm as a
10160 # - For all functions that have a denormalized input and #
10208 # we have a DENORM that needs to be converted into an EXOP.
10282 tst.b LOCAL_HI(%a0) # is dst a DENORM?
10285 # dst op is a DENORM. we have to normalize the mantissa to see if the
10286 # result would be inexact for the given precision. make a copy of the
11370 # ok, I have a problem with putting the dst op at FP_DST. the emulation
11374 # 8/17/93 - this turns out to be more of a "cleanliness" standpoint
11375 # then a potential bug. to begin with, only the dyadic functions
11421 long fatan - tbl_unsupp # 0a: fatan
11437 long fneg - tbl_unsupp # 1a: fneg
11469 long ftst - tbl_unsupp # 3a: ftst
11501 long fsneg - tbl_unsupp # 5a: fsneg
11547 # For norms/denorms, scale the exponents such that a multiply #
11639 mov.l %d1,%d2 # make a copy
11655 # - if overflow or inexact is enabled, we need a multiply result rounded to
11697 # calculate a result rounded to extended precision.
11766 # - if overflow or inexact is enabled, we need a multiply result rounded to
12042 # Norms can be emulated w/ a regular fmove instruction. For #
12281 mov.l %d1,%d2 # make a copy
12307 fabs.x %fp0,%fp1 # make a copy of result
12364 # For norms/denorms, scale the exponents such that a divide #
13061 mov.l %d1,%d2 # make a copy
13087 fabs.x %fp0,%fp1 # make a copy of result
13325 # here. For norms, load the rounding mode/prec, execute a "fintrz", #
13327 # For denorms, force the j-bit to a one and do the same as for #
13328 # norms. Denorms are so low that the answer will either be a zero or a #
13373 # to a very small NORM and ship it to the NORM routine.
13565 mov.l %d1,%d2 # make a copy
13622 mov.l %d1,%d2 # make a copy
13842 # 'N' bit for a negative QNAN or SNAN input so we must squelch it here.
13853 # DENORMs are a little more difficult.
13854 # If you have a 2 DENORMs, then you can just force the j-bit to a one
13856 # If you have a DENORM and an INF or ZERO, just force the DENORM's j-bit to a one
13951 # compute a result. Check if the regular operands would have taken #
14010 mov.l %d1,%d2 # make a copy
14057 mov.l %d1,%d2 # make a copy
14082 fabs.x %fp0,%fp1 # make a copy of result
14292 # compute a result. Check if the regular operands would have taken #
14357 mov.l %d1,%d2 # make a copy
14410 mov.l %d1,%d2 # make a copy
14467 mov.l %d1,%d2 # make a copy
14495 fabs.x %fp0,%fp1 # make a copy of result
14502 # we don't know if the result was an underflow that rounded up to a 1
14503 # or a normalized number that rounded down to a 1. so, redo the entire
14820 mov.l %d1,%d2 # make a copy
14859 # ok, so now the result has a exponent equal to the smallest normalized
14864 # rounded "up" or a normalized number rounded "down".
14994 # one operand is a ZERO and the other is a DENORM or NORM. scale
15273 mov.l %d1,%d2 # make a copy
15312 # ok, so now the result has a exponent equal to the smallest normalized
15317 # rounded "up" or a normalized number rounded "down".
15419 # the signs are opposite, so, return a ZERO w/ the sign of the dst ZERO
15446 # one operand is a ZERO and the other is a DENORM or a NORM.
15524 # For norms/denorms, scale the exponents such that a sqrt #
15657 # the exponent is 3fff or 3ffe. if it's 3ffe, then it's a safe number
15704 mov.l %d1,%d2 # make a copy
15861 # plus two, then set the smallest exponent to a very small value as a #
15966 # norm() - normalize the mantissa if the operand was a DENORM #
15978 # normalize the operand if it was a DENORM. Add this normalization #
16015 # scale_sqrt(): scale the input operand exponent so a subsequent #
16093 # norm() - normalize the mantissa if the operand was a DENORM #
16105 # normalize the operand if it was a DENORM. Add this normalization #
16157 # If either operand (but not both operands) of an operation is a #
16161 # If either operand to an operation is a signalling NAN (SNAN), #
16165 # then the SNAN is converted to a nonsignalling NAN (by setting the #
16178 cmp.b DTAG(%a6), &QNAN # is the dst a QNAN?
16265 # the stacked fdbcc instruction opcode and then branches to a routine #
16269 # If a BSUN exception should be indicated, the BSUN and ABSUN #
18049 # for a bsun exception.
18062 mov.l %d0,%a0 # save result for a moment
18065 mov.l %d1,%d0 # make a copy
18240 btst &0x5,EXC_EXTWORD(%a6) # is it a move in or out?
18474 # table to convert a pre-decrement bit string into a post-increment
18529 mov.w %d0,%d1 # make a copy