Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-13 23:51:39 +00:00
Code Issues Packages Projects Releases Wiki Activity
dbbcbb2d95
linux/arch/m68k/math-emu/fp_util.S
Jörn Engel 6ab3d5624e Remove obsolete #include <linux/config.h> 
Signed-off-by: Jörn Engel <joern@wohnheim.fh-wedel.de>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
2006-06-30 19:25:36 +02:00

1455 lines
36 KiB
ArmAsm
Raw Blame History

/*
* fp_util.S
*
* Copyright Roman Zippel, 1997. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, and the entire permission notice in its entirety,
* including the disclaimer of warranties.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* ALTERNATIVELY, this product may be distributed under the terms of
* the GNU General Public License, in which case the provisions of the GPL are
* required INSTEAD OF the above restrictions. (This clause is
* necessary due to a potential bad interaction between the GPL and
* the restrictions contained in a BSD-style copyright.)
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "fp_emu.h"
/*
* Here are lots of conversion and normalization functions mainly
* used by fp_scan.S
* Note that these functions are optimized for "normal" numbers,
* these are handled first and exit as fast as possible, this is
* especially important for fp_normalize_ext/fp_conv_ext2ext, as
* it's called very often.
* The register usage is optimized for fp_scan.S and which register
* is currently at that time unused, be careful if you want change
* something here. %d0 and %d1 is always usable, sometimes %d2 (or
* only the lower half) most function have to return the %a0
* unmodified, so that the caller can immediately reuse it.
*/
.globl fp_ill, fp_end
| exits from fp_scan:
| illegal instruction
fp_ill:
printf ,"fp_illegal\n"
rts
| completed instruction
fp_end:
tst.l (TASK_MM-8,%a2)
jmi 1f
tst.l (TASK_MM-4,%a2)
jmi 1f
tst.l (TASK_MM,%a2)
jpl 2f
1: printf ,"oops:%p,%p,%p\n",3,%a2@(TASK_MM-8),%a2@(TASK_MM-4),%a2@(TASK_MM)
2: clr.l %d0
rts
.globl fp_conv_long2ext, fp_conv_single2ext
.globl fp_conv_double2ext, fp_conv_ext2ext
.globl fp_normalize_ext, fp_normalize_double
.globl fp_normalize_single, fp_normalize_single_fast
.globl fp_conv_ext2double, fp_conv_ext2single
.globl fp_conv_ext2long, fp_conv_ext2short
.globl fp_conv_ext2byte
.globl fp_finalrounding_single, fp_finalrounding_single_fast
.globl fp_finalrounding_double
.globl fp_finalrounding, fp_finaltest, fp_final
/*
* First several conversion functions from a source operand
* into the extended format. Note, that only fp_conv_ext2ext
* normalizes the number and is always called after the other
* conversion functions, which only move the information into
* fp_ext structure.
*/
| fp_conv_long2ext:
|
| args: %d0 = source (32-bit long)
| %a0 = destination (ptr to struct fp_ext)
fp_conv_long2ext:
printf PCONV,"l2e: %p -> %p(",2,%d0,%a0
clr.l %d1 | sign defaults to zero
tst.l %d0
jeq fp_l2e_zero | is source zero?
jpl 1f | positive?
moveq #1,%d1
neg.l %d0
1: swap %d1
move.w #0x3fff+31,%d1
move.l %d1,(%a0)+ | set sign / exp
move.l %d0,(%a0)+ | set mantissa
clr.l (%a0)
subq.l #8,%a0 | restore %a0
printx PCONV,%a0@
printf PCONV,")\n"
rts
| source is zero
fp_l2e_zero:
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)
subq.l #8,%a0
printx PCONV,%a0@
printf PCONV,")\n"
rts
| fp_conv_single2ext
| args: %d0 = source (single-precision fp value)
| %a0 = dest (struct fp_ext *)
fp_conv_single2ext:
printf PCONV,"s2e: %p -> %p(",2,%d0,%a0
move.l %d0,%d1
lsl.l #8,%d0 | shift mantissa
lsr.l #8,%d1 | exponent / sign
lsr.l #7,%d1
lsr.w #8,%d1
jeq fp_s2e_small | zero / denormal?
cmp.w #0xff,%d1 | NaN / Inf?
jeq fp_s2e_large
bset #31,%d0 | set explizit bit
add.w #0x3fff-0x7f,%d1 | re-bias the exponent.
9: move.l %d1,(%a0)+ | fp_ext.sign, fp_ext.exp
move.l %d0,(%a0)+ | high lword of fp_ext.mant
clr.l (%a0) | low lword = 0
subq.l #8,%a0
printx PCONV,%a0@
printf PCONV,")\n"
rts
| zeros and denormalized
fp_s2e_small:
| exponent is zero, so explizit bit is already zero too
tst.l %d0
jeq 9b
move.w #0x4000-0x7f,%d1
jra 9b
| infinities and NAN
fp_s2e_large:
bclr #31,%d0 | clear explizit bit
move.w #0x7fff,%d1
jra 9b
fp_conv_double2ext:
#ifdef FPU_EMU_DEBUG
getuser.l %a1@(0),%d0,fp_err_ua2,%a1
getuser.l %a1@(4),%d1,fp_err_ua2,%a1
printf PCONV,"d2e: %p%p -> %p(",3,%d0,%d1,%a0
#endif
getuser.l (%a1)+,%d0,fp_err_ua2,%a1
move.l %d0,%d1
lsl.l #8,%d0 | shift high mantissa
lsl.l #3,%d0
lsr.l #8,%d1 | exponent / sign
lsr.l #7,%d1
lsr.w #5,%d1
jeq fp_d2e_small | zero / denormal?
cmp.w #0x7ff,%d1 | NaN / Inf?
jeq fp_d2e_large
bset #31,%d0 | set explizit bit
add.w #0x3fff-0x3ff,%d1 | re-bias the exponent.
9: move.l %d1,(%a0)+ | fp_ext.sign, fp_ext.exp
move.l %d0,(%a0)+
getuser.l (%a1)+,%d0,fp_err_ua2,%a1
move.l %d0,%d1
lsl.l #8,%d0
lsl.l #3,%d0
move.l %d0,(%a0)
moveq #21,%d0
lsr.l %d0,%d1
or.l %d1,-(%a0)
subq.l #4,%a0
printx PCONV,%a0@
printf PCONV,")\n"
rts
| zeros and denormalized
fp_d2e_small:
| exponent is zero, so explizit bit is already zero too
tst.l %d0
jeq 9b
move.w #0x4000-0x3ff,%d1
jra 9b
| infinities and NAN
fp_d2e_large:
bclr #31,%d0 | clear explizit bit
move.w #0x7fff,%d1
jra 9b
| fp_conv_ext2ext:
| originally used to get longdouble from userspace, now it's
| called before arithmetic operations to make sure the number
| is normalized [maybe rename it?].
| args: %a0 = dest (struct fp_ext *)
| returns 0 in %d0 for a NaN, otherwise 1
fp_conv_ext2ext:
printf PCONV,"e2e: %p(",1,%a0
printx PCONV,%a0@
printf PCONV,"), "
move.l (%a0)+,%d0
cmp.w #0x7fff,%d0 | Inf / NaN?
jeq fp_e2e_large
move.l (%a0),%d0
jpl fp_e2e_small | zero / denorm?
| The high bit is set, so normalization is irrelevant.
fp_e2e_checkround:
subq.l #4,%a0
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
move.b (%a0),%d0
jne fp_e2e_round
#endif
printf PCONV,"%p(",1,%a0
printx PCONV,%a0@
printf PCONV,")\n"
moveq #1,%d0
rts
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
fp_e2e_round:
fp_set_sr FPSR_EXC_INEX2
clr.b (%a0)
move.w (FPD_RND,FPDATA),%d2
jne fp_e2e_roundother | %d2 == 0, round to nearest
tst.b %d0 | test guard bit
jpl 9f | zero is closer
btst #0,(11,%a0) | test lsb bit
jne fp_e2e_doroundup | round to infinity
lsl.b #1,%d0 | check low bits
jeq 9f | round to zero
fp_e2e_doroundup:
addq.l #1,(8,%a0)
jcc 9f
addq.l #1,(4,%a0)
jcc 9f
move.w #0x8000,(4,%a0)
addq.w #1,(2,%a0)
9: printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
fp_e2e_roundother:
subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 1f | %d2 > 2, round to +infinity
tst.b (1,%a0) | to -inf
jne fp_e2e_doroundup | negative, round to infinity
jra 9b | positive, round to zero
1: tst.b (1,%a0) | to +inf
jeq fp_e2e_doroundup | positive, round to infinity
jra 9b | negative, round to zero
#endif
| zeros and subnormals:
| try to normalize these anyway.
fp_e2e_small:
jne fp_e2e_small1 | high lword zero?
move.l (4,%a0),%d0
jne fp_e2e_small2
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
clr.l %d0
move.b (-4,%a0),%d0
jne fp_e2e_small3
#endif
| Genuine zero.
clr.w -(%a0)
subq.l #2,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
moveq #1,%d0
rts
| definitely subnormal, need to shift all 64 bits
fp_e2e_small1:
bfffo %d0{#0,#32},%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
1: move.w %d2,(%a0)+
move.w %d1,%d2
jeq fp_e2e_checkround
| fancy 64-bit double-shift begins here
lsl.l %d2,%d0
move.l %d0,(%a0)+
move.l (%a0),%d0
move.l %d0,%d1
lsl.l %d2,%d0
move.l %d0,(%a0)
neg.w %d2
and.w #0x1f,%d2
lsr.l %d2,%d1
or.l %d1,-(%a0)
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
fp_e2e_extra1:
clr.l %d0
move.b (-4,%a0),%d0
neg.w %d2
add.w #24,%d2
jcc 1f
clr.b (-4,%a0)
lsl.l %d2,%d0
or.l %d0,(4,%a0)
jra fp_e2e_checkround
1: addq.w #8,%d2
lsl.l %d2,%d0
move.b %d0,(-4,%a0)
lsr.l #8,%d0
or.l %d0,(4,%a0)
#endif
jra fp_e2e_checkround
| pathologically small subnormal
fp_e2e_small2:
bfffo %d0{#0,#32},%d1
add.w #32,%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Beyond pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
1: move.w %d2,(%a0)+
ext.l %d1
jeq fp_e2e_checkround
clr.l (4,%a0)
sub.w #32,%d2
jcs 1f
lsl.l %d1,%d0 | lower lword needs only to be shifted
move.l %d0,(%a0) | into the higher lword
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
clr.l %d0
move.b (-4,%a0),%d0
clr.b (-4,%a0)
neg.w %d1
add.w #32,%d1
bfins %d0,(%a0){%d1,#8}
#endif
jra fp_e2e_checkround
1: neg.w %d1 | lower lword is splitted between
bfins %d0,(%a0){%d1,#32} | higher and lower lword
#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
jra fp_e2e_checkround
#else
move.w %d1,%d2
jra fp_e2e_extra1
| These are extremely small numbers, that will mostly end up as zero
| anyway, so this is only important for correct rounding.
fp_e2e_small3:
bfffo %d0{#24,#8},%d1
add.w #40,%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
1: move.w %d2,(%a0)+
ext.l %d1
jeq fp_e2e_checkround
cmp.w #8,%d1
jcs 2f
1: clr.b (-4,%a0)
sub.w #64,%d1
jcs 1f
add.w #24,%d1
lsl.l %d1,%d0
move.l %d0,(%a0)
jra fp_e2e_checkround
1: neg.w %d1
bfins %d0,(%a0){%d1,#8}
jra fp_e2e_checkround
2: lsl.l %d1,%d0
move.b %d0,(-4,%a0)
lsr.l #8,%d0
move.b %d0,(7,%a0)
jra fp_e2e_checkround
#endif
1: move.l %d0,%d1 | lower lword is splitted between
lsl.l %d2,%d0 | higher and lower lword
move.l %d0,(%a0)
move.l %d1,%d0
neg.w %d2
add.w #32,%d2
lsr.l %d2,%d0
move.l %d0,-(%a0)
jra fp_e2e_checkround
| Infinities and NaNs
fp_e2e_large:
move.l (%a0)+,%d0
jne 3f
1: tst.l (%a0)
jne 4f
moveq #1,%d0
2: subq.l #8,%a0
printf PCONV,"%p(",1,%a0
printx PCONV,%a0@
printf PCONV,")\n"
rts
| we have maybe a NaN, shift off the highest bit
3: lsl.l #1,%d0
jeq 1b
| we have a NaN, clear the return value
4: clrl %d0
jra 2b
/*
* Normalization functions. Call these on the output of general
* FP operators, and before any conversion into the destination
* formats. fp_normalize_ext has always to be called first, the
* following conversion functions expect an already normalized
* number.
*/
| fp_normalize_ext:
| normalize an extended in extended (unpacked) format, basically
| it does the same as fp_conv_ext2ext, additionally it also does
| the necessary postprocessing checks.
| args: %a0 (struct fp_ext *)
| NOTE: it does _not_ modify %a0/%a1 and the upper word of %d2
fp_normalize_ext:
printf PNORM,"ne: %p(",1,%a0
printx PNORM,%a0@
printf PNORM,"), "
move.l (%a0)+,%d0
cmp.w #0x7fff,%d0 | Inf / NaN?
jeq fp_ne_large
move.l (%a0),%d0
jpl fp_ne_small | zero / denorm?
| The high bit is set, so normalization is irrelevant.
fp_ne_checkround:
subq.l #4,%a0
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
move.b (%a0),%d0
jne fp_ne_round
#endif
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
fp_ne_round:
fp_set_sr FPSR_EXC_INEX2
clr.b (%a0)
move.w (FPD_RND,FPDATA),%d2
jne fp_ne_roundother | %d2 == 0, round to nearest
tst.b %d0 | test guard bit
jpl 9f | zero is closer
btst #0,(11,%a0) | test lsb bit
jne fp_ne_doroundup | round to infinity
lsl.b #1,%d0 | check low bits
jeq 9f | round to zero
fp_ne_doroundup:
addq.l #1,(8,%a0)
jcc 9f
addq.l #1,(4,%a0)
jcc 9f
addq.w #1,(2,%a0)
move.w #0x8000,(4,%a0)
9: printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
fp_ne_roundother:
subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 1f | %d2 > 2, round to +infinity
tst.b (1,%a0) | to -inf
jne fp_ne_doroundup | negative, round to infinity
jra 9b | positive, round to zero
1: tst.b (1,%a0) | to +inf
jeq fp_ne_doroundup | positive, round to infinity
jra 9b | negative, round to zero
#endif
| Zeros and subnormal numbers
| These are probably merely subnormal, rather than "denormalized"
| numbers, so we will try to make them normal again.
fp_ne_small:
jne fp_ne_small1 | high lword zero?
move.l (4,%a0),%d0
jne fp_ne_small2
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
clr.l %d0
move.b (-4,%a0),%d0
jne fp_ne_small3
#endif
| Genuine zero.
clr.w -(%a0)
subq.l #2,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| Subnormal.
fp_ne_small1:
bfffo %d0{#0,#32},%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
fp_set_sr FPSR_EXC_UNFL
1: move.w %d2,(%a0)+
move.w %d1,%d2
jeq fp_ne_checkround
| This is exactly the same 64-bit double shift as seen above.
lsl.l %d2,%d0
move.l %d0,(%a0)+
move.l (%a0),%d0
move.l %d0,%d1
lsl.l %d2,%d0
move.l %d0,(%a0)
neg.w %d2
and.w #0x1f,%d2
lsr.l %d2,%d1
or.l %d1,-(%a0)
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
fp_ne_extra1:
clr.l %d0
move.b (-4,%a0),%d0
neg.w %d2
add.w #24,%d2
jcc 1f
clr.b (-4,%a0)
lsl.l %d2,%d0
or.l %d0,(4,%a0)
jra fp_ne_checkround
1: addq.w #8,%d2
lsl.l %d2,%d0
move.b %d0,(-4,%a0)
lsr.l #8,%d0
or.l %d0,(4,%a0)
#endif
jra fp_ne_checkround
| May or may not be subnormal, if so, only 32 bits to shift.
fp_ne_small2:
bfffo %d0{#0,#32},%d1
add.w #32,%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Beyond pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
fp_set_sr FPSR_EXC_UNFL
1: move.w %d2,(%a0)+
ext.l %d1
jeq fp_ne_checkround
clr.l (4,%a0)
sub.w #32,%d1
jcs 1f
lsl.l %d1,%d0 | lower lword needs only to be shifted
move.l %d0,(%a0) | into the higher lword
#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
clr.l %d0
move.b (-4,%a0),%d0
clr.b (-4,%a0)
neg.w %d1
add.w #32,%d1
bfins %d0,(%a0){%d1,#8}
#endif
jra fp_ne_checkround
1: neg.w %d1 | lower lword is splitted between
bfins %d0,(%a0){%d1,#32} | higher and lower lword
#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
jra fp_ne_checkround
#else
move.w %d1,%d2
jra fp_ne_extra1
| These are extremely small numbers, that will mostly end up as zero
| anyway, so this is only important for correct rounding.
fp_ne_small3:
bfffo %d0{#24,#8},%d1
add.w #40,%d1
move.w -(%a0),%d2
sub.w %d1,%d2
jcc 1f
| Pathologically small, denormalize.
add.w %d2,%d1
clr.w %d2
1: move.w %d2,(%a0)+
ext.l %d1
jeq fp_ne_checkround
cmp.w #8,%d1
jcs 2f
1: clr.b (-4,%a0)
sub.w #64,%d1
jcs 1f
add.w #24,%d1
lsl.l %d1,%d0
move.l %d0,(%a0)
jra fp_ne_checkround
1: neg.w %d1
bfins %d0,(%a0){%d1,#8}
jra fp_ne_checkround
2: lsl.l %d1,%d0
move.b %d0,(-4,%a0)
lsr.l #8,%d0
move.b %d0,(7,%a0)
jra fp_ne_checkround
#endif
| Infinities and NaNs, again, same as above.
fp_ne_large:
move.l (%a0)+,%d0
jne 3f
1: tst.l (%a0)
jne 4f
2: subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| we have maybe a NaN, shift off the highest bit
3: move.l %d0,%d1
lsl.l #1,%d1
jne 4f
clr.l (-4,%a0)
jra 1b
| we have a NaN, test if it is signaling
4: bset #30,%d0
jne 2b
fp_set_sr FPSR_EXC_SNAN
move.l %d0,(-4,%a0)
jra 2b
| these next two do rounding as per the IEEE standard.
| values for the rounding modes appear to be:
| 0: Round to nearest
| 1: Round to zero
| 2: Round to -Infinity
| 3: Round to +Infinity
| both functions expect that fp_normalize was already
| called (and extended argument is already normalized
| as far as possible), these are used if there is different
| rounding precision is selected and before converting
| into single/double
| fp_normalize_double:
| normalize an extended with double (52-bit) precision
| args: %a0 (struct fp_ext *)
fp_normalize_double:
printf PNORM,"nd: %p(",1,%a0
printx PNORM,%a0@
printf PNORM,"), "
move.l (%a0)+,%d2
tst.w %d2
jeq fp_nd_zero | zero / denormalized
cmp.w #0x7fff,%d2
jeq fp_nd_huge | NaN / infinitive.
sub.w #0x4000-0x3ff,%d2 | will the exponent fit?
jcs fp_nd_small | too small.
cmp.w #0x7fe,%d2
jcc fp_nd_large | too big.
addq.l #4,%a0
move.l (%a0),%d0 | low lword of mantissa
| now, round off the low 11 bits.
fp_nd_round:
moveq #21,%d1
lsl.l %d1,%d0 | keep 11 low bits.
jne fp_nd_checkround | Are they non-zero?
| nothing to do here
9: subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| Be careful with the X bit! It contains the lsb
| from the shift above, it is needed for round to nearest.
fp_nd_checkround:
fp_set_sr FPSR_EXC_INEX2 | INEX2 bit
and.w #0xf800,(2,%a0) | clear bits 0-10
move.w (FPD_RND,FPDATA),%d2 | rounding mode
jne 2f | %d2 == 0, round to nearest
tst.l %d0 | test guard bit
jpl 9b | zero is closer
| here we test the X bit by adding it to %d2
clr.w %d2 | first set z bit, addx only clears it
addx.w %d2,%d2 | test lsb bit
| IEEE754-specified "round to even" behaviour. If the guard
| bit is set, then the number is odd, so rounding works like
| in grade-school arithmetic (i.e. 1.5 rounds to 2.0)
| Otherwise, an equal distance rounds towards zero, so as not
| to produce an odd number. This is strange, but it is what
| the standard says.
jne fp_nd_doroundup | round to infinity
lsl.l #1,%d0 | check low bits
jeq 9b | round to zero
fp_nd_doroundup:
| round (the mantissa, that is) towards infinity
add.l #0x800,(%a0)
jcc 9b | no overflow, good.
addq.l #1,-(%a0) | extend to high lword
jcc 1f | no overflow, good.
| Yow! we have managed to overflow the mantissa. Since this
| only happens when %d1 was 0xfffff800, it is now zero, so
| reset the high bit, and increment the exponent.
move.w #0x8000,(%a0)
addq.w #1,-(%a0)
cmp.w #0x43ff,(%a0)+ | exponent now overflown?
jeq fp_nd_large | yes, so make it infinity.
1: subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
2: subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 3f | %d2 > 2, round to +infinity
| Round to +Inf or -Inf. High word of %d2 contains the
| sign of the number, by the way.
swap %d2 | to -inf
tst.b %d2
jne fp_nd_doroundup | negative, round to infinity
jra 9b | positive, round to zero
3: swap %d2 | to +inf
tst.b %d2
jeq fp_nd_doroundup | positive, round to infinity
jra 9b | negative, round to zero
| Exponent underflow. Try to make a denormal, and set it to
| the smallest possible fraction if this fails.
fp_nd_small:
fp_set_sr FPSR_EXC_UNFL | set UNFL bit
move.w #0x3c01,(-2,%a0) | 2**-1022
neg.w %d2 | degree of underflow
cmp.w #32,%d2 | single or double shift?
jcc 1f
| Again, another 64-bit double shift.
move.l (%a0),%d0
move.l %d0,%d1
lsr.l %d2,%d0
move.l %d0,(%a0)+
move.l (%a0),%d0
lsr.l %d2,%d0
neg.w %d2
add.w #32,%d2
lsl.l %d2,%d1
or.l %d1,%d0
move.l (%a0),%d1
move.l %d0,(%a0)
| Check to see if we shifted off any significant bits
lsl.l %d2,%d1
jeq fp_nd_round | Nope, round.
bset #0,%d0 | Yes, so set the "sticky bit".
jra fp_nd_round | Now, round.
| Another 64-bit single shift and store
1: sub.w #32,%d2
cmp.w #32,%d2 | Do we really need to shift?
jcc 2f | No, the number is too small.
move.l (%a0),%d0
clr.l (%a0)+
move.l %d0,%d1
lsr.l %d2,%d0
neg.w %d2
add.w #32,%d2
| Again, check to see if we shifted off any significant bits.
tst.l (%a0)
jeq 1f
bset #0,%d0 | Sticky bit.
1: move.l %d0,(%a0)
lsl.l %d2,%d1
jeq fp_nd_round
bset #0,%d0
jra fp_nd_round
| Sorry, the number is just too small.
2: clr.l (%a0)+
clr.l (%a0)
moveq #1,%d0 | Smallest possible fraction,
jra fp_nd_round | round as desired.
| zero and denormalized
fp_nd_zero:
tst.l (%a0)+
jne 1f
tst.l (%a0)
jne 1f
subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts | zero. nothing to do.
| These are not merely subnormal numbers, but true denormals,
| i.e. pathologically small (exponent is 2**-16383) numbers.
| It is clearly impossible for even a normal extended number
| with that exponent to fit into double precision, so just
| write these ones off as "too darn small".
1: fp_set_sr FPSR_EXC_UNFL | Set UNFL bit
clr.l (%a0)
clr.l -(%a0)
move.w #0x3c01,-(%a0) | i.e. 2**-1022
addq.l #6,%a0
moveq #1,%d0
jra fp_nd_round | round.
| Exponent overflow. Just call it infinity.
fp_nd_large:
move.w #0x7ff,%d0
and.w (6,%a0),%d0
jeq 1f
fp_set_sr FPSR_EXC_INEX2
1: fp_set_sr FPSR_EXC_OVFL
move.w (FPD_RND,FPDATA),%d2
jne 3f | %d2 = 0 round to nearest
1: move.w #0x7fff,(-2,%a0)
clr.l (%a0)+
clr.l (%a0)
2: subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
3: subq.w #2,%d2
jcs 5f | %d2 < 2, round to zero
jhi 4f | %d2 > 2, round to +infinity
tst.b (-3,%a0) | to -inf
jne 1b
jra 5f
4: tst.b (-3,%a0) | to +inf
jeq 1b
5: move.w #0x43fe,(-2,%a0)
moveq #-1,%d0
move.l %d0,(%a0)+
move.w #0xf800,%d0
move.l %d0,(%a0)
jra 2b
| Infinities or NaNs
fp_nd_huge:
subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| fp_normalize_single:
| normalize an extended with single (23-bit) precision
| args: %a0 (struct fp_ext *)
fp_normalize_single:
printf PNORM,"ns: %p(",1,%a0
printx PNORM,%a0@
printf PNORM,") "
addq.l #2,%a0
move.w (%a0)+,%d2
jeq fp_ns_zero | zero / denormalized
cmp.w #0x7fff,%d2
jeq fp_ns_huge | NaN / infinitive.
sub.w #0x4000-0x7f,%d2 | will the exponent fit?
jcs fp_ns_small | too small.
cmp.w #0xfe,%d2
jcc fp_ns_large | too big.
move.l (%a0)+,%d0 | get high lword of mantissa
fp_ns_round:
tst.l (%a0) | check the low lword
jeq 1f
| Set a sticky bit if it is non-zero. This should only
| affect the rounding in what would otherwise be equal-
| distance situations, which is what we want it to do.
bset #0,%d0
1: clr.l (%a0) | zap it from memory.
| now, round off the low 8 bits of the hi lword.
tst.b %d0 | 8 low bits.
jne fp_ns_checkround | Are they non-zero?
| nothing to do here
subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
fp_ns_checkround:
fp_set_sr FPSR_EXC_INEX2 | INEX2 bit
clr.b -(%a0) | clear low byte of high lword
subq.l #3,%a0
move.w (FPD_RND,FPDATA),%d2 | rounding mode
jne 2f | %d2 == 0, round to nearest
tst.b %d0 | test guard bit
jpl 9f | zero is closer
btst #8,%d0 | test lsb bit
| round to even behaviour, see above.
jne fp_ns_doroundup | round to infinity
lsl.b #1,%d0 | check low bits
jeq 9f | round to zero
fp_ns_doroundup:
| round (the mantissa, that is) towards infinity
add.l #0x100,(%a0)
jcc 9f | no overflow, good.
| Overflow. This means that the %d1 was 0xffffff00, so it
| is now zero. We will set the mantissa to reflect this, and
| increment the exponent (checking for overflow there too)
move.w #0x8000,(%a0)
addq.w #1,-(%a0)
cmp.w #0x407f,(%a0)+ | exponent now overflown?
jeq fp_ns_large | yes, so make it infinity.
9: subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| check nondefault rounding modes
2: subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 3f | %d2 > 2, round to +infinity
tst.b (-3,%a0) | to -inf
jne fp_ns_doroundup | negative, round to infinity
jra 9b | positive, round to zero
3: tst.b (-3,%a0) | to +inf
jeq fp_ns_doroundup | positive, round to infinity
jra 9b | negative, round to zero
| Exponent underflow. Try to make a denormal, and set it to
| the smallest possible fraction if this fails.
fp_ns_small:
fp_set_sr FPSR_EXC_UNFL | set UNFL bit
move.w #0x3f81,(-2,%a0) | 2**-126
neg.w %d2 | degree of underflow
cmp.w #32,%d2 | single or double shift?
jcc 2f
| a 32-bit shift.
move.l (%a0),%d0
move.l %d0,%d1
lsr.l %d2,%d0
move.l %d0,(%a0)+
| Check to see if we shifted off any significant bits.
neg.w %d2
add.w #32,%d2
lsl.l %d2,%d1
jeq 1f
bset #0,%d0 | Sticky bit.
| Check the lower lword
1: tst.l (%a0)
jeq fp_ns_round
clr (%a0)
bset #0,%d0 | Sticky bit.
jra fp_ns_round
| Sorry, the number is just too small.
2: clr.l (%a0)+
clr.l (%a0)
moveq #1,%d0 | Smallest possible fraction,
jra fp_ns_round | round as desired.
| Exponent overflow. Just call it infinity.
fp_ns_large:
tst.b (3,%a0)
jeq 1f
fp_set_sr FPSR_EXC_INEX2
1: fp_set_sr FPSR_EXC_OVFL
move.w (FPD_RND,FPDATA),%d2
jne 3f | %d2 = 0 round to nearest
1: move.w #0x7fff,(-2,%a0)
clr.l (%a0)+
clr.l (%a0)
2: subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
3: subq.w #2,%d2
jcs 5f | %d2 < 2, round to zero
jhi 4f | %d2 > 2, round to +infinity
tst.b (-3,%a0) | to -inf
jne 1b
jra 5f
4: tst.b (-3,%a0) | to +inf
jeq 1b
5: move.w #0x407e,(-2,%a0)
move.l #0xffffff00,(%a0)+
clr.l (%a0)
jra 2b
| zero and denormalized
fp_ns_zero:
tst.l (%a0)+
jne 1f
tst.l (%a0)
jne 1f
subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts | zero. nothing to do.
| These are not merely subnormal numbers, but true denormals,
| i.e. pathologically small (exponent is 2**-16383) numbers.
| It is clearly impossible for even a normal extended number
| with that exponent to fit into single precision, so just
| write these ones off as "too darn small".
1: fp_set_sr FPSR_EXC_UNFL | Set UNFL bit
clr.l (%a0)
clr.l -(%a0)
move.w #0x3f81,-(%a0) | i.e. 2**-126
addq.l #6,%a0
moveq #1,%d0
jra fp_ns_round | round.
| Infinities or NaNs
fp_ns_huge:
subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| fp_normalize_single_fast:
| normalize an extended with single (23-bit) precision
| this is only used by fsgldiv/fsgdlmul, where the
| operand is not completly normalized.
| args: %a0 (struct fp_ext *)
fp_normalize_single_fast:
printf PNORM,"nsf: %p(",1,%a0
printx PNORM,%a0@
printf PNORM,") "
addq.l #2,%a0
move.w (%a0)+,%d2
cmp.w #0x7fff,%d2
jeq fp_nsf_huge | NaN / infinitive.
move.l (%a0)+,%d0 | get high lword of mantissa
fp_nsf_round:
tst.l (%a0) | check the low lword
jeq 1f
| Set a sticky bit if it is non-zero. This should only
| affect the rounding in what would otherwise be equal-
| distance situations, which is what we want it to do.
bset #0,%d0
1: clr.l (%a0) | zap it from memory.
| now, round off the low 8 bits of the hi lword.
tst.b %d0 | 8 low bits.
jne fp_nsf_checkround | Are they non-zero?
| nothing to do here
subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
fp_nsf_checkround:
fp_set_sr FPSR_EXC_INEX2 | INEX2 bit
clr.b -(%a0) | clear low byte of high lword
subq.l #3,%a0
move.w (FPD_RND,FPDATA),%d2 | rounding mode
jne 2f | %d2 == 0, round to nearest
tst.b %d0 | test guard bit
jpl 9f | zero is closer
btst #8,%d0 | test lsb bit
| round to even behaviour, see above.
jne fp_nsf_doroundup | round to infinity
lsl.b #1,%d0 | check low bits
jeq 9f | round to zero
fp_nsf_doroundup:
| round (the mantissa, that is) towards infinity
add.l #0x100,(%a0)
jcc 9f | no overflow, good.
| Overflow. This means that the %d1 was 0xffffff00, so it
| is now zero. We will set the mantissa to reflect this, and
| increment the exponent (checking for overflow there too)
move.w #0x8000,(%a0)
addq.w #1,-(%a0)
cmp.w #0x407f,(%a0)+ | exponent now overflown?
jeq fp_nsf_large | yes, so make it infinity.
9: subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| check nondefault rounding modes
2: subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 3f | %d2 > 2, round to +infinity
tst.b (-3,%a0) | to -inf
jne fp_nsf_doroundup | negative, round to infinity
jra 9b | positive, round to zero
3: tst.b (-3,%a0) | to +inf
jeq fp_nsf_doroundup | positive, round to infinity
jra 9b | negative, round to zero
| Exponent overflow. Just call it infinity.
fp_nsf_large:
tst.b (3,%a0)
jeq 1f
fp_set_sr FPSR_EXC_INEX2
1: fp_set_sr FPSR_EXC_OVFL
move.w (FPD_RND,FPDATA),%d2
jne 3f | %d2 = 0 round to nearest
1: move.w #0x7fff,(-2,%a0)
clr.l (%a0)+
clr.l (%a0)
2: subq.l #8,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
3: subq.w #2,%d2
jcs 5f | %d2 < 2, round to zero
jhi 4f | %d2 > 2, round to +infinity
tst.b (-3,%a0) | to -inf
jne 1b
jra 5f
4: tst.b (-3,%a0) | to +inf
jeq 1b
5: move.w #0x407e,(-2,%a0)
move.l #0xffffff00,(%a0)+
clr.l (%a0)
jra 2b
| Infinities or NaNs
fp_nsf_huge:
subq.l #4,%a0
printf PNORM,"%p(",1,%a0
printx PNORM,%a0@
printf PNORM,")\n"
rts
| conv_ext2int (macro):
| Generates a subroutine that converts an extended value to an
| integer of a given size, again, with the appropriate type of
| rounding.
| Macro arguments:
| s: size, as given in an assembly instruction.
| b: number of bits in that size.
| Subroutine arguments:
| %a0: source (struct fp_ext *)
| Returns the integer in %d0 (like it should)
.macro conv_ext2int s,b
.set inf,(1<<(\b-1))-1 | i.e. MAXINT
printf PCONV,"e2i%d: %p(",2,#\b,%a0
printx PCONV,%a0@
printf PCONV,") "
addq.l #2,%a0
move.w (%a0)+,%d2 | exponent
jeq fp_e2i_zero\b | zero / denorm (== 0, here)
cmp.w #0x7fff,%d2
jeq fp_e2i_huge\b | Inf / NaN
sub.w #0x3ffe,%d2
jcs fp_e2i_small\b
cmp.w #\b,%d2
jhi fp_e2i_large\b
move.l (%a0),%d0
move.l %d0,%d1
lsl.l %d2,%d1
jne fp_e2i_round\b
tst.l (4,%a0)
jne fp_e2i_round\b
neg.w %d2
add.w #32,%d2
lsr.l %d2,%d0
9: tst.w (-4,%a0)
jne 1f
tst.\s %d0
jmi fp_e2i_large\b
printf PCONV,"-> %p\n",1,%d0
rts
1: neg.\s %d0
jeq 1f
jpl fp_e2i_large\b
1: printf PCONV,"-> %p\n",1,%d0
rts
fp_e2i_round\b:
fp_set_sr FPSR_EXC_INEX2 | INEX2 bit
neg.w %d2
add.w #32,%d2
.if \b>16
jeq 5f
.endif
lsr.l %d2,%d0
move.w (FPD_RND,FPDATA),%d2 | rounding mode
jne 2f | %d2 == 0, round to nearest
tst.l %d1 | test guard bit
jpl 9b | zero is closer
btst %d2,%d0 | test lsb bit (%d2 still 0)
jne fp_e2i_doroundup\b
lsl.l #1,%d1 | check low bits
jne fp_e2i_doroundup\b
tst.l (4,%a0)
jeq 9b
fp_e2i_doroundup\b:
addq.l #1,%d0
jra 9b
| check nondefault rounding modes
2: subq.w #2,%d2
jcs 9b | %d2 < 2, round to zero
jhi 3f | %d2 > 2, round to +infinity
tst.w (-4,%a0) | to -inf
jne fp_e2i_doroundup\b | negative, round to infinity
jra 9b | positive, round to zero
3: tst.w (-4,%a0) | to +inf
jeq fp_e2i_doroundup\b | positive, round to infinity
jra 9b | negative, round to zero
| we are only want -2**127 get correctly rounded here,
| since the guard bit is in the lower lword.
| everything else ends up anyway as overflow.
.if \b>16
5: move.w (FPD_RND,FPDATA),%d2 | rounding mode
jne 2b | %d2 == 0, round to nearest
move.l (4,%a0),%d1 | test guard bit
jpl 9b | zero is closer
lsl.l #1,%d1 | check low bits
jne fp_e2i_doroundup\b
jra 9b
.endif
fp_e2i_zero\b:
clr.l %d0
tst.l (%a0)+
jne 1f
tst.l (%a0)
jeq 3f
1: subq.l #4,%a0
fp_clr_sr FPSR_EXC_UNFL | fp_normalize_ext has set this bit
fp_e2i_small\b:
fp_set_sr FPSR_EXC_INEX2
clr.l %d0
move.w (FPD_RND,FPDATA),%d2 | rounding mode
subq.w #2,%d2
jcs 3f | %d2 < 2, round to nearest/zero
jhi 2f | %d2 > 2, round to +infinity
tst.w (-4,%a0) | to -inf
jeq 3f
subq.\s #1,%d0
jra 3f
2: tst.w (-4,%a0) | to +inf
jne 3f
addq.\s #1,%d0
3: printf PCONV,"-> %p\n",1,%d0
rts
fp_e2i_large\b:
fp_set_sr FPSR_EXC_OPERR
move.\s #inf,%d0
tst.w (-4,%a0)
jeq 1f
addq.\s #1,%d0
1: printf PCONV,"-> %p\n",1,%d0
rts
fp_e2i_huge\b:
move.\s (%a0),%d0
tst.l (%a0)
jne 1f
tst.l (%a0)
jeq fp_e2i_large\b
| fp_normalize_ext has set this bit already
| and made the number nonsignaling
1: fp_tst_sr FPSR_EXC_SNAN
jne 1f
fp_set_sr FPSR_EXC_OPERR
1: printf PCONV,"-> %p\n",1,%d0
rts
.endm
fp_conv_ext2long:
conv_ext2int l,32
fp_conv_ext2short:
conv_ext2int w,16
fp_conv_ext2byte:
conv_ext2int b,8
fp_conv_ext2double:
jsr fp_normalize_double
printf PCONV,"e2d: %p(",1,%a0
printx PCONV,%a0@
printf PCONV,"), "
move.l (%a0)+,%d2
cmp.w #0x7fff,%d2
jne 1f
move.w #0x7ff,%d2
move.l (%a0)+,%d0
jra 2f
1: sub.w #0x3fff-0x3ff,%d2
move.l (%a0)+,%d0
jmi 2f
clr.w %d2
2: lsl.w #5,%d2
lsl.l #7,%d2
lsl.l #8,%d2
move.l %d0,%d1
lsl.l #1,%d0
lsr.l #4,%d0
lsr.l #8,%d0
or.l %d2,%d0
putuser.l %d0,(%a1)+,fp_err_ua2,%a1
moveq #21,%d0
lsl.l %d0,%d1
move.l (%a0),%d0
lsr.l #4,%d0
lsr.l #7,%d0
or.l %d1,%d0
putuser.l %d0,(%a1),fp_err_ua2,%a1
#ifdef FPU_EMU_DEBUG
getuser.l %a1@(-4),%d0,fp_err_ua2,%a1
getuser.l %a1@(0),%d1,fp_err_ua2,%a1
printf PCONV,"%p(%08x%08x)\n",3,%a1,%d0,%d1
#endif
rts
fp_conv_ext2single:
jsr fp_normalize_single
printf PCONV,"e2s: %p(",1,%a0
printx PCONV,%a0@
printf PCONV,"), "
move.l (%a0)+,%d1
cmp.w #0x7fff,%d1
jne 1f
move.w #0xff,%d1
move.l (%a0)+,%d0
jra 2f
1: sub.w #0x3fff-0x7f,%d1
move.l (%a0)+,%d0
jmi 2f
clr.w %d1
2: lsl.w #8,%d1
lsl.l #7,%d1
lsl.l #8,%d1
bclr #31,%d0
lsr.l #8,%d0
or.l %d1,%d0
printf PCONV,"%08x\n",1,%d0
rts
| special return addresses for instr that
| encode the rounding precision in the opcode
| (e.g. fsmove,fdmove)
fp_finalrounding_single:
addq.l #8,%sp
jsr fp_normalize_ext
jsr fp_normalize_single
jra fp_finaltest
fp_finalrounding_single_fast:
addq.l #8,%sp
jsr fp_normalize_ext
jsr fp_normalize_single_fast
jra fp_finaltest
fp_finalrounding_double:
addq.l #8,%sp
jsr fp_normalize_ext
jsr fp_normalize_double
jra fp_finaltest
| fp_finaltest:
| set the emulated status register based on the outcome of an
| emulated instruction.
fp_finalrounding:
addq.l #8,%sp
| printf ,"f: %p\n",1,%a0
jsr fp_normalize_ext
move.w (FPD_PREC,FPDATA),%d0
subq.w #1,%d0
jcs fp_finaltest
jne 1f
jsr fp_normalize_single
jra 2f
1: jsr fp_normalize_double
2:| printf ,"f: %p\n",1,%a0
fp_finaltest:
| First, we do some of the obvious tests for the exception
| status byte and condition code bytes of fp_sr here, so that
| they do not have to be handled individually by every
| emulated instruction.
clr.l %d0
addq.l #1,%a0
tst.b (%a0)+ | sign
jeq 1f
bset #FPSR_CC_NEG-24,%d0 | N bit
1: cmp.w #0x7fff,(%a0)+ | exponent
jeq 2f
| test for zero
moveq #FPSR_CC_Z-24,%d1
tst.l (%a0)+
jne 9f
tst.l (%a0)
jne 9f
jra 8f
| infinitiv and NAN
2: moveq #FPSR_CC_NAN-24,%d1
move.l (%a0)+,%d2
lsl.l #1,%d2 | ignore high bit
jne 8f
tst.l (%a0)
jne 8f
moveq #FPSR_CC_INF-24,%d1
8: bset %d1,%d0
9: move.b %d0,(FPD_FPSR+0,FPDATA) | set condition test result
| move instructions enter here
| Here, we test things in the exception status byte, and set
| other things in the accrued exception byte accordingly.
| Emulated instructions can set various things in the former,
| as defined in fp_emu.h.
fp_final:
move.l (FPD_FPSR,FPDATA),%d0
#if 0
btst #FPSR_EXC_SNAN,%d0 | EXC_SNAN
jne 1f
btst #FPSR_EXC_OPERR,%d0 | EXC_OPERR
jeq 2f
1: bset #FPSR_AEXC_IOP,%d0 | set IOP bit
2: btst #FPSR_EXC_OVFL,%d0 | EXC_OVFL
jeq 1f
bset #FPSR_AEXC_OVFL,%d0 | set OVFL bit
1: btst #FPSR_EXC_UNFL,%d0 | EXC_UNFL
jeq 1f
btst #FPSR_EXC_INEX2,%d0 | EXC_INEX2
jeq 1f
bset #FPSR_AEXC_UNFL,%d0 | set UNFL bit
1: btst #FPSR_EXC_DZ,%d0 | EXC_INEX1
jeq 1f
bset #FPSR_AEXC_DZ,%d0 | set DZ bit
1: btst #FPSR_EXC_OVFL,%d0 | EXC_OVFL
jne 1f
btst #FPSR_EXC_INEX2,%d0 | EXC_INEX2
jne 1f
btst #FPSR_EXC_INEX1,%d0 | EXC_INEX1
jeq 2f
1: bset #FPSR_AEXC_INEX,%d0 | set INEX bit
2: move.l %d0,(FPD_FPSR,FPDATA)
#else
| same as above, greatly optimized, but untested (yet)
move.l %d0,%d2
lsr.l #5,%d0
move.l %d0,%d1
lsr.l #4,%d1
or.l %d0,%d1
and.b #0x08,%d1
move.l %d2,%d0
lsr.l #6,%d0
or.l %d1,%d0
move.l %d2,%d1
lsr.l #4,%d1
or.b #0xdf,%d1
and.b %d1,%d0
move.l %d2,%d1
lsr.l #7,%d1
and.b #0x80,%d1
or.b %d1,%d0
and.b #0xf8,%d0
or.b %d0,%d2
move.l %d2,(FPD_FPSR,FPDATA)
#endif
move.b (FPD_FPSR+2,FPDATA),%d0
and.b (FPD_FPCR+2,FPDATA),%d0
jeq 1f
printf ,"send signal!!!\n"
1: jra fp_end
Reference in New Issue View Git Blame Copy Permalink