Lines Matching refs:Then
626 # then stored in either the FP regfile, data regfile, or memory. #
629 # If the exception is enabled, then this handler must create the #
866 # then stored in either the FP regfile, data regfile, or memory. #
869 # If the exception is enabled, then this handler must create the #
972 # (0x00000000_80000000_00000000), then the machine will take an
1005 # (0x00000000_80000000_00000000), then the machine will take an
1033 # (0x00000000_80000000_00000000), then the machine will take an
1036 # then we have to branch to real_inex.
1156 # from the FP register file. The instruction is then emulated by #
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 #
1162 # this exception into the FPU in the fsave state frame and then exit #
1168 # If a Trace exception is pending, then the current exception stack #
1173 # as the result of emulation, then an exit either occurs through #
1176 # should occur, then we must create an exception stack frame of that #
1230 # exception, then the a7' calculated here is wrong since it doesn't
1277 # input is an UNNORM, then convert it to a NORM, DENORM, or ZERO.
1569 # address register was the stack pointer used from user mode, then let's update
1570 # it here. if it was used from supervisor mode, then we have to handle this
1631 # was exact, then a branch to _real_inex() is made.
1643 # from FPIAR and put it in the trace stack frame then jump to _real_trace().
1733 # exception occurred from user mode, then simply update a7 and exit normally.
2050 # trace stack frame then jump to _real_trace().
2196 # the strategy is to move the exception frame "down" 12 bytes. then, we
2236 # the strategy is to move the exception frame "down" 12 bytes. then, we
2276 # the strategy is to move the exception frame "down" 12 bytes. then, we
2306 # if we're stuffing a source operand back into an fsave frame then we
2421 # emulation, then the result is stored to the destination register and #
2423 # signalled as a result of emulation, then an fsave state frame #
2448 # then we must create an 8 word "FPU disabled" exception stack frame #
2454 # "callout" returns a failing result indicating an access error, then #
2594 # store a result. then, only fcmp will branch back and pick up a dst operand.
2663 # enabled? if so, then we have to stuff an overflow frame into the FPU.
2680 # or underflow that was disabled, then we have to force an overflow or
2722 # the trace stack frame then jump to _real_trace().
3103 # do just this and then exits through _real_operr(). #
3293 # do just this and then exits through _real_snan(). #
3303 # if the effective addressing mode was -() or ()+, then the address #
3305 # was -(a7) from supervisor mode, then the exception frame currently #
3362 # fpsp_unsupp(), then we need to do nothing else for them here.
3491 # post-increment, then
3594 # instruction in order to get this value and then store it to the #
3772 # adjusts the operand using fix_skewed_ops() and then branches to #
3840 # can occur because then FPU is disabled or the instruction is to be #
4250 # then we return the size of the dump and the string to the caller #
4269 # If the data register holds a zero, then the #
4294 # if the bit string is a zero, then the operation is a no-op
5417 # plus two, then set the smallest exponent to a very small value as a #
5533 # of the difference between the original and new exponent. Then, #
5660 # of the difference between the original and new exponent. Then, #
5714 # nonsignalling NAN, then that NAN is returned as the result. If both #
5715 # operands are nonsignalling NANs, then the destination operand #
5718 # then, the SNAN bit is set in the FPSR EXC byte. If the SNAN trap #
5719 # enable bit is set in the FPCR, then the trap is taken and the #
5721 # then the SNAN is converted to a nonsignalling NAN (by setting the #
6180 # If (G,R,S == 0) then result is exact and round is done, else set
6206 # If sign of fp number = 0 (positive), then add 1 to l. #
6210 bmi.w truncate # if positive then truncate
6223 # If sign of fp number = 1 (negative), then add 1 to l. #
6227 bpl.w truncate # if negative then truncate
6240 # If (g=1), then add 1 to l and if (r=s=0), then clear l #
6245 bcc.w truncate # if (g=1) then
6822 # according to the scale factor passed in d0. Then, round the #
7102 # precision. Then, bindec() is called to create the appropriate #
7105 # to-memory routines, then a special exit must be made so that the #
7402 # so, denorm and round and then use generic store single routine to
7507 # (3) if exp still equals zero, then insert original exponent
7509 # if exp now equals one, then it overflowed so call ovf_res.
7631 # so, denorm and round and then use generic store double routine to
7718 # (3) if exp still equals zero, then insert original exponent
7720 # if exp now equals one, then it overflowed so call ovf_res.
8060 # normalized then we really don't need to go through this scaling. but for now,
8097 # extended precision. if the original operation was extended, then we have this
8100 # of this operation then has its exponent scaled by -0x6000 to create the
8136 # - if precision is extended, then we have the EXOP. simply bias the exponent
8208 # extended precision. if the original operation was extended, then we have this
8211 # of this operation then has its exponent scaled by -0x6000 to create the
8217 # for fun, let's use only extended precision, round to zero. then, let
8256 # if the rnd mode is anything but RZ, then we have to re-do the above
8644 # if underflow or inexact is enabled, then go calculate the EXOP first.
9212 # dst INF is set, then then j-bit of the result INF is also set).
9660 # here. For norms, load the rounding mode/prec, execute a "fint", then #
9767 # then store the resulting FPSR bits. #
10295 # If you have a 2 DENORMs, then you can just force the j-bit to a one
10299 # If you have a DENORM and a NORM with opposite signs, then use fcmp_norm, also.
11070 # occur. Then, check result exponent to see if exception would have #
11523 # occur. Then, check result exponent to see if exception would have #
12098 # the exponent is 3fff or 3ffe. if it's 3ffe, then it's a safe number
12573 # For a7, if the increment amount is one, then we have to #
12637 # For a7, if the decrement amount is one, then we have to #
12899 # get_packed(): fetch a packed operand from memory and then #
12918 # Then, fetch the operand from memory. If the fetch fails, exit #
13120 # get the integer digit then skip down & get the rest of the
13140 # then inc d1 (=2) to point to the next long word and reset d3 to 0
13203 # routine is necessary. If so, then check the sign of the exponent
13394 # same sign. If the exp was pos then multiply fp1*fp0;
14580 # -(an)+ register gets returned to its pre-exception value and then #
14686 # handler, then AN must be returned to its pre-instruction value.
14738 # mode, then also also wasn't updated. if it was user mode, then
Indexes created Thu Oct 23 22:10:10 GMT 2025