diff options
Diffstat (limited to 'ANDROID_3.4.5/arch/m68k/math-emu/fp_util.S')
| -rw-r--r-- | ANDROID_3.4.5/arch/m68k/math-emu/fp_util.S | 1454 |
1 files changed, 0 insertions, 1454 deletions
diff --git a/ANDROID_3.4.5/arch/m68k/math-emu/fp_util.S b/ANDROID_3.4.5/arch/m68k/math-emu/fp_util.S deleted file mode 100644 index b093b85f..00000000 --- a/ANDROID_3.4.5/arch/m68k/math-emu/fp_util.S +++ /dev/null @@ -1,1454 +0,0 @@ -/* - * 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 |