Lines Matching refs:WE
675 # maybe we can avoid the subroutine call.
720 # maybe we can make these entry points ONLY the OVFL entry points of each routine.
726 # we must save the default result regardless of whether
731 # the exceptional possibilities we have left ourselves with are ONLY overflow
748 # overflow is enabled AND overflow, of course, occurred. so, we have the EXOP
766 # we must jump to real_inex().
924 # now, what's left that's not dyadic is fsincos. we can distinguish it
963 # maybe we can make these entry points ONLY the OVFL entry points of each routine.
973 # underflow exception. Since this is incorrect, we need to check
975 # no underflow was called for. We do these checks only in
979 # the exceptional possibilities we have left ourselves with are ONLY overflow
998 # overflow is enabled AND overflow, of course, occurred. so, we have the EXOP
1000 # well, we simply have to get to go to _real_unfl()!
1006 # underflow exception. Since this is incorrect, we check here to see
1028 # we must jump to real_inex().
1036 # then we have to branch to real_inex.
1159 # saved, then we check to see if any enabled exceptions resulted from #
1160 # instruction emulation. If none, then we exit through the "callout" #
1161 # _fpsp_done(). If there is an enabled FP exception, then we insert #
1176 # should occur, then we must create an exception stack frame of that #
1231 # stack an ea. however, we don't need an a7' for this case anyways.
1275 # we don't know whether the src operand or the dst operand (or both) is the
1330 # we determine the highest priority exception(if any) set by the
1385 # * this is the case where we must call _real_inex() now or else
1404 # here, we insert the correct fsave status value into the fsave frame for the
1461 # here, we count on norm not to alter a0...
1493 # here, we count on norm not to alter a0...
1570 # it here. if it was used from supervisor mode, then we have to handle this
1596 # the extended precision result is still in fp0. but, we need to save it
1597 # somewhere on the stack until we can copy it to its final resting place.
1598 # here, we're counting on the top of the stack to be the old place-holders
1599 # for fp0/fp1 which have already been restored. that way, we can write
1667 # we don't mess with the existing fsave frame. just re-insert it and
1741 mov.l EXC_A7(%a6),%a0 # restore a7 whether we need
1764 # the extended precision result is still in fp0. but, we need to save it
1765 # somewhere on the stack until we can copy it to its final resting place
1875 # we determine the highest priority exception(if any) set by the
1911 # addressing mode was (a7)+. if so, we'll need to shift the
1923 # shift the stack frame "up". we don't really care about the <ea> field.
1963 # * this is the case where we must call _real_inex() now or else
1982 # here, we insert the correct fsave status value into the fsave frame for the
1985 # as a reminder for future predicted pain and agony, we are passing in fsave the
2142 # addressing mode was -(a7). if so, we'll need to shift the
2196 # the strategy is to move the exception frame "down" 12 bytes. then, we
2213 # now, we copy the default result to it's proper location
2236 # the strategy is to move the exception frame "down" 12 bytes. then, we
2253 # now, we copy the default result to it's proper location
2276 # the strategy is to move the exception frame "down" 12 bytes. then, we
2293 # now, we copy the default result to it's proper location
2306 # if we're stuffing a source operand back into an fsave frame then we
2425 # FPU before exiting. In either the enabled or disabled cases, we #
2426 # must also check if a Trace exception is pending, in which case, we #
2428 # stack frame. If no Trace is pending, we simply exit through #
2447 # has higher priority, we check the disabled bit in the PCR. If set, #
2448 # then we must create an 8 word "FPU disabled" exception stack frame #
2455 # we must create an access error stack frame from the current stack #
2466 # So, we must check to see if it's disabled and handle that case separately.
2493 # here, we will have:
2593 # now, we're left with ftst and fcmp. so, first let's tag them so that they don't
2627 # we determine the highest priority exception(if any) set by the
2632 # now, we save the result, unless, of course, the operation was ftst or fcmp.
2663 # enabled? if so, then we have to stuff an overflow frame into the FPU.
2672 # an enabled exception occurred. we have to insert the exception type back into
2680 # or underflow that was disabled, then we have to force an overflow or
2774 # the data has been fetched from the supervisor stack, but we have not
2953 # The FPU is disabled and so we should really have taken the "Line
2954 # F Emulator" exception. So, here we create an 8-word stack frame
2955 # from our 4-word stack frame. This means we must calculate the length
3006 # here, we actually create the 8-word frame from the 4-word frame,
3140 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3143 # cause an operr so we don't need to check for them here.
3161 # operand error exceptions. we do this here before passing control to
3165 # through here. we simply need to test the sign of the src
3336 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3357 # snan exceptions. we do this here before passing control to
3362 # fpsp_unsupp(), then we need to do nothing else for them here.
3363 # for byte, word, and long, we simply need to test the sign of the src
3630 # w/ an exponent value of 0x401e. we convert this to extended precision here.
3644 # Here, we zero the ccode and exception byte field since we're going to
3645 # emulate the whole instruction. Notice, though, that we don't kill the
3647 # to extended before arriving here. Therefore, we need to retain the
3722 # inexact exceptions. we do this here before passing control to
3799 # here, we simply see if the operand in the fsave frame needs to be "unskewed".
3865 # the exception was an "F-Line Illegal" exception. we check to see
3889 # so, we need to convert the F-Line exception stack frame into an
3893 # but, if the FPU is disabled, then we need to jump to the FPU diabled
3981 # exceptional or non-exceptional cases, we must check to see if the #
3982 # Trace exception is enabled. If so, then we must create a Trace #
4135 # until I feel like fixing this, we'll sidestep the exception.
4184 # the user has enabled some exceptions. we figure not to see this too
4194 # no exception that was enabled was set BUT if we got an exact overflow
4207 # we'll insert this new exception into the FPU and then return.
4214 # or underflow that was disabled, then we have to force an overflow or
4225 # appropriate type. don't forget to "skew" the source operand in case we
4305 # the ftrapcc instruction should take a trap. so, here we must create a
4362 # overwritten by the "fs<cc> -(An)". We must shift the stack frame "down"
4395 # The ftrap<cc>, fs<cc>, or fdb<cc> is to take an enabled bsun. we must convert
4435 # as usual, we have to check for trace mode being on here. since instructions
4463 # the fscc instruction should take a trace trap. so, here we must create a
4984 # fdbcc emulation failed. here, we create an access error frame
5190 #--THEN WE RETURN SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
5243 #--THEN WE RETURN SGN*COS(R). SGN*COS(R) IS COMPUTED BY
5307 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5650 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5679 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5687 #--we want P+p = W+w but |p| <= half ulp of P
5688 #--Then, we need to compute A := R-P and a := r-p
5698 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but
5991 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
6081 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
6110 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
6118 #--we want P+p = W+w but |p| <= half ulp of P
6119 #--Then, we need to compute A := R-P and a := r-p
6129 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but
6373 #--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
6376 #--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
6387 #--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
6388 #--WE CHOSE F TO BE +-2^K * 1.BBBB1
6392 #-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
6406 #--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
6431 #--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
6435 #--WHAT WE HAVE HERE IS MERELY A1 = A3, A2 = A1/A3, A3 = A2/A3.
6932 # Notes: If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R, #
6952 # Note also that we use the FMOVEM instruction to move X #
7080 # inefficiency, we stay away from denormalized numbers #
7081 # the best we can. For |X| >= 2^(-16312), the #
7266 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7268 #--TO FULLY USE THE PIPELINE, WE COMPUTE S = R*R
7429 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7431 #--TO FULLY USE THE PIPELINE, WE COMPUTE S = R*R
7658 # here, we build the result in a tmp location so as not to disturb the input
7711 # overflow. Thus, we calculate sinh(X) as follows: #
7825 # Thus, we calculate sinh(X) as follows: #
7948 # 6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we #
8355 #--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
8371 #--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
8600 #--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
8601 #--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
8606 #--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
9610 # we may need to read the fpsr for the last fp op in t_catch2().
9635 # the multiply factor that we're trying to create should be a denorm
9636 # for the multiply to work. therefore, we're going to actually do a
9639 # later. we don't do this with the DENORMs above because this method
9643 subi.l &-0x3fff,%d0 # how many should we shift?
9691 # The source input is below 1, so we check for denormalized numbers
10171 # - we only return the EXOP here if either underflow or #
10217 # we have a DENORM that needs to be converted into an EXOP.
10294 # dst op is a DENORM. we have to normalize the mantissa to see if the
10296 # dst so we don't screw up the version passed to us.
10353 # we find out if this occurred by doing an fsave and #
10354 # checking the exception bit. if one did occur, then we #
10391 # we must set INEX/AINEX since the fmul/fdiv/fmov emulation may not!
11001 # has been decoded. Flow continues here where we now decode
11380 # routines aren't supposed to alter the operands but we've just squashed
11628 # normalized then we really don't need to go through this scaling. but for now,
11664 # - if overflow or inexact is enabled, we need a multiply result rounded to
11665 # extended precision. if the original operation was extended, then we have this
11666 # result. if the original operation was single or double, we have to do another
11704 # - if precision is extended, then we have the EXOP. simply bias the exponent
11705 # with an extra -0x6000. if the precision is single or double, we need to
11766 # no, it didn't overflow; we have correct result
11775 # - if overflow or inexact is enabled, we need a multiply result rounded to
11776 # extended precision. if the original operation was extended, then we have this
11777 # result. if the original operation was single or double, we have to do another
11787 # will we get the correct answer.
11824 # if the rnd mode is anything but RZ, then we have to re-do the above
11825 # multiplication because we used RZ for all.
11879 # we still don't know if underflow occurred. result is ~ equal to 2. but,
11880 # we don't know if the result was an underflow that rounded up to a 2 or
11996 # strictly compatible w/ the 68881/882, we make sure to return an
12086 # precision selected is extended. so...we cannot get an underflow
12228 # therefore, we must return the result rounded to extended precision.
12270 # OVFL is not enabled; therefore, we must create the default result by
12320 # no, it didn't overflow; we have correct result
12647 # we still don't know if underflow occurred. result is ~ equal to 1. but,
12648 # we don't know if the result was an underflow that rounded up to a 1
12859 # precision selected is extended. so...we can not get an underflow
13008 # therefore, we must return the result rounded to extended precision.
13050 # OVFL is not enabled; therefore, we must create the default result by
13100 # no, it didn't overflow; we have correct result
13279 # so, we could either set these manually or force the DENORM
13381 # so, we could either set these manually or force the DENORM
13482 # precision selected is extended. so...we can not get an underflow
13623 # therefore, we must return the result rounded to extended precision.
13665 # OVFL is not enabled; therefore, we must create the default result by
13715 # no, it didn't overflow; we have correct result
13851 # 'N' bit for a negative QNAN or SNAN input so we must squelch it here.
14095 # no, it didn't overflow; we have correct result
14174 # we still don't know if underflow occurred. result is ~ equal to 2. but,
14175 # we don't know if the result was an underflow that rounded up to a 2 or
14510 # we still don't know if underflow occurred. result is ~ equal to 1. but,
14511 # we don't know if the result was an underflow that rounded up to a 1
14872 # now, we must determine whether the pre-rounded result was an underflow
14874 # so, we do this be re-executing the add using RZ as the rounding mode and
14985 # - therefore, we return +ZERO if the rounding modes are RN,RZ, or RP.
15036 # ok, so it's not an OPERR. but, we do have to remember to return the
15045 bpl.b fadd_inf_done # yes; we're done
15055 bpl.b fadd_inf_done # yes; we
15325 # now, we must determine whether the pre-rounded result was an underflow
15327 # so, we do this be re-executing the add using RZ as the rounding mode and
15437 # - therefore, we return +ZERO if the rounding mode is RN,RZ, or RP
15488 # ok, so it's not an OPERR. but we do have to remember to return
15665 # we're on the line here and the distinguising characteristic is whether
15705 # therefore, we must return the result rounded to extended precision.
15747 # OVFL is not enabled; therefore, we must create the default result by
15800 # no, it didn't overflow; we have correct result
16340 # counter. However, the true branch may set bsun so we check to see #
16388 bne.w fdbcc_bsun # yes; we have an exception
16407 bne.w fdbcc_bsun # yes; we have an exception
16423 bne.w fdbcc_bsun # yes; we have an exception
16430 bne.w fdbcc_bsun # yes; we have an exception
16448 bne.w fdbcc_bsun # yes; we have an exception
16464 bne.w fdbcc_bsun # yes; we have an exception
16483 bne.w fdbcc_bsun # yes; we have an exception
16499 bne.w fdbcc_bsun # yes; we have an exception
16506 bne.w fdbcc_bsun # yes; we have an exception
16524 bne.w fdbcc_bsun # yes; we have an exception
16540 bne.w fdbcc_bsun # yes; we have an exception
16559 bne.w fdbcc_bsun # yes; we have an exception
16573 bne.w fdbcc_bsun # yes; we have an exception
16590 bne.w fdbcc_bsun # yes; we have an exception
16627 bne.w fdbcc_bsun # yes; we have an exception
16640 bne.w fdbcc_bsun # yes; we have an exception
16656 bne.w fdbcc_bsun # yes; we have an exception
16663 bne.w fdbcc_bsun # yes; we have an exception
16679 bne.w fdbcc_bsun # yes; we have an exception
16686 bne.w fdbcc_bsun # yes; we have an exception
16967 # For the IEEE nonaware tests, we set the result based on the #
16968 # floating point condition codes. In addition, we check to see #
17210 # For the IEEE aware tests, we only have to set the result based on the #
17309 # For the IEEE aware tests, we only have to set the result based on the #
17438 # we will need to jump to the ftrapcc vector. the stack frame
17537 # For the IEEE nonaware tests, we set the result based on the #
17538 # floating point condition codes. In addition, we check to see #
17787 # For the IEEE aware tests, we only have to set the result based on the #
17879 # For the IEEE aware tests, we only have to set the result based on the #
18186 # from an "Unimplemented Effective Address" exception handler. So, we #
18188 # by a _{i,d,}mem_read() call, we must exit through the special #
18192 # a lookup table such that we can determine the number of bytes #
18200 # then we return the size of the dump and the string to the caller #
18245 # but, make sure that we've calculated ea and advanced the opword pointer
18263 # here, we convert it to be just like the others...
18275 # we're also passing "size" and "strg" back to the calling routine
19077 # we clear the value here if it should actually be suppressed.
19395 # need to set immediate data flag here since we'll need to do
19402 # here, the <ea> is stacked correctly. however, we must update the
19414 # mode so we don't even worry about this tricky case here : )
19446 # modes. Also, while we're at it, the index register itself must get #
19448 # So, for -(an), we must subtract 8 off of the stacked <ea> value #
19450 # For (an)+, the stacked <ea> is correct but we must adjust An by +12. #
19630 # we're not using op011 for now...
20373 # we copy the extended precision result to FP_SCR0 so that the reserved
20374 # 16-bit field gets zeroed. we do this since we promise not to disturb
20389 # we must not yet write the extended precision data to the stack
20390 # in the pre-decrement case from supervisor mode or else we'll corrupt
20413 # we don't want to do the write if the exception occurred in supervisor mode
20448 # operand is a normalized number. first, we check to see if the move out
20499 # here, we know that the operand would UNFL if moved out to single prec,
20686 # operand is a normalized number. first, we check to see if the move out
20725 rts # no; so we're finished
20728 # here, we know that the operand would UNFL if moved out to double prec,
20992 # we'll have to change this, but for now, tough luck!!!
21008 # we zero the exponent
21036 # we don't want to do the write if the exception occurred in supervisor mode
21356 # For a7, if the increment amount is one, then we have to #
21420 # For a7, if the decrement amount is one, then we have to #
21629 # value in d0. The FP number can be DENORM or SNAN so we have to be #
21630 # careful that we don't take an exception here. #
21723 # to see if (threshold - exponent) is > 65 in which case we can
21725 # we have to call the denormalization routine.
22236 # this function. so, as long as we don't disturb it, we are "returning" it.
22520 # must distinguish now "Unnormalized zeroes" which we
22761 # we know that underflow has occurred. aunfl should be set if INEX2 is also set.
22821 # we know that underflow has occurred. aunfl should be set if INEX2 is also set.
23082 mov.l 0x4(%a0),FP_SCR0_HI(%a6) # so we don't alter it
23120 dbf.w %d2,e_gd # if we have used all 3 digits, exit loop
23160 # mantissa. We will unroll the loop once.
23912 # 10^24 is exact. If the input was denormalized, we must
23948 # for DENORM, we must calculate:
23950 # since the input operand is a DENORM, we can't multiply it directly.
23951 # so, we do the multiplication of the exponents and mantissas separately.
23952 # in this way, we avoid underflow on intermediate stages of the
24186 # Since ICTR <> 0, we have already been through one adjustment,
24618 # So, we first call restore() which makes sure that any updated #
24620 # we change the stack to an acess error stack frame. #
24695 # here's where we actually create the access error frame from the
24724 # instruction value. but since we're exiting to the access error
24726 # we do that here.
24774 # if it's a fmove out instruction, we don't have to fix a7
24775 # because we hadn't changed it yet. if it's an opclass two
Indexes created Tue Oct 28 12:10:06 GMT 2025