ifpsp060/src/pfpsp.S

616 # then stored in either the FP regfile, data regfile, or memory.	#
619 #	If the exception is enabled, then this handler must create the	#
856 # then stored in either the FP regfile, data regfile, or memory.	#
859 #	If the exception is enabled, then this handler must create the	#
962 # (0x00000000_80000000_00000000), then the machine will take an
995 # (0x00000000_80000000_00000000), then the machine will take an
1023 # (0x00000000_80000000_00000000), then the machine will take an
1026 # then we have to branch to real_inex.
1146 # from the FP register file. The instruction is then emulated by	#
1149 # saved, then we check to see if any enabled exceptions resulted from	#
1150 # instruction emulation. If none, then we exit through the "callout"	#
1151 # _fpsp_done(). If there is an enabled FP exception, then we insert	#
1152 # this exception into the FPU in the fsave state frame and then exit	#
1158 # If a Trace exception is pending, then the current exception stack	#
1163 # as the result of emulation, then an exit either occurs through	#
1166 # should occur, then we must create an exception stack frame of that	#
1220 # exception, then the a7' calculated here is wrong since it doesn't
1267 # input is an UNNORM, then convert it to a NORM, DENORM, or ZERO.
1559 # address register was the stack pointer used from user mode, then let's update
1560 # it here. if it was used from supervisor mode, then we have to handle this
1621 # was exact, then a branch to _real_inex() is made.
1633 # from FPIAR and put it in the trace stack frame then jump to _real_trace().
1723 # exception occurred from user mode, then simply update a7 and exit normally.
2040 # trace stack frame then jump to _real_trace().
2186 # the strategy is to move the exception frame "down" 12 bytes. then, we
2226 # the strategy is to move the exception frame "down" 12 bytes. then, we
2266 # the strategy is to move the exception frame "down" 12 bytes. then, we
2296 # if we're stuffing a source operand back into an fsave frame then we
2411 # emulation, then the result is stored to the destination register and	#
2413 # signalled as a result of emulation, then an fsave state frame		#
2438 # then we must create an 8 word "FPU disabled" exception stack frame	#
2444 # "callout" returns a failing result indicating an access error, then	#
2584 # store a result. then, only fcmp will branch back and pick up a dst operand.
2653 # enabled? if so, then we have to stuff an overflow frame into the FPU.
2670 # or underflow that was disabled, then we have to force an overflow or
2712 # the trace stack frame then jump to _real_trace().
3093 # do just this and then exits through _real_operr().			#
3283 # do just this and then exits through _real_snan().			#
3293 # if the effective addressing mode was -() or ()+, then the address	#
3295 # was -(a7) from supervisor mode, then the exception frame currently	#
3352 # fpsp_unsupp(), then we need to do nothing else for them here.
3481 # post-increment, then the address register did not get updated.
3584 # instruction in order to get this value and then store it to the	#
3762 # adjusts the operand using fix_skewed_ops() and then branches to	#
3830 # can occur because then FPU is disabled or the instruction is to be	#
4240 # then we return the size of the dump and the string to the caller	#
4259 #	If the data register holds a zero, then the			#
4284 # if the bit string is a zero, then the operation is a no-op
5407 # plus two, then set the smallest exponent to a very small value as a	#
5704 # nonsignalling NAN, then that NAN is returned as the result. If both	#
5705 # operands are nonsignalling NANs, then the destination operand		#
5708 # then, the SNAN bit is set in the FPSR EXC byte. If the SNAN trap	#
5709 # enable bit is set in the FPCR, then the trap is taken and the		#
5711 # then the SNAN is converted to a nonsignalling NAN (by setting the	#
6170 # If (G,R,S == 0) then result is exact and round is done, else set
6196 #	If sign of fp number = 0 (positive), then add 1 to l.	#
6200 	bmi.w		truncate		# if positive then truncate
6213 #	If sign of fp number = 1 (negative), then add 1 to l.	#
6217 	bpl.w		truncate		# if negative then truncate
6230 #	If (g=1), then add 1 to l and if (r=s=0), then clear l	#
6235 	bcc.w		truncate		# if (g=1) then
7095 # to-memory routines, then a special exit must be made so that the	#
7392 # so, denorm and round and then use generic store single routine to
7497 # (3) if exp still equals zero, then insert original exponent
7499 #     if exp now equals one, then it overflowed so call ovf_res.
7621 # so, denorm and round and then use generic store double routine to
7708 # (3) if exp still equals zero, then insert original exponent
7710 #     if exp now equals one, then it overflowed so call ovf_res.
8050 # normalized then we really don't need to go through this scaling. but for now,
8087 # extended precision. if the original operation was extended, then we have this
8090 # of this operation then has its exponent scaled by -0x6000 to create the
8126 # - if precision is extended, then we have the EXOP. simply bias the exponent
8198 # extended precision. if the original operation was extended, then we have this
8201 # of this operation then has its exponent scaled by -0x6000 to create the
8207 # for fun, let's use only extended precision, round to zero. then, let
8246 # if the rnd mode is anything but RZ, then we have to re-do the above
8634 # if underflow or inexact is enabled, then go calculate the EXOP first.
9202 # dst INF is set, then then j-bit of the result INF is also set).
9650 # here. For norms, load the rounding mode/prec, execute a "fint", then	#
9757 # then store the resulting FPSR bits.					#
10285 # If you have a 2 DENORMs, then you can just force the j-bit to a one
10289 # If you have a DENORM and a NORM with opposite signs, then use fcmp_norm, also.
12088 # the exponent is 3fff or 3ffe. if it's 3ffe, then it's a safe number
12563 #	For a7, if the increment amount is one, then we have to		#
12627 #	For a7, if the decrement amount is one, then we have to		#
12889 #	get_packed(): fetch a packed operand from memory and then	#
13110 #  get the integer digit then skip down & get the rest of the
13130 #  then inc d1 (=2) to point to the next long word and reset d3 to 0
13193 # routine is necessary.  If so, then check the sign of the exponent
13384 #  same sign. If the exp was pos then multiply fp1*fp0;
14570 # -(an)+ register gets returned to its pre-exception value and then	#
14676 # handler, then AN must be returned to its pre-instruction value.
14728 # mode, then also also wasn't updated. if it was user mode, then