URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [arch/] [i386/] [math-emu/] [reg_round.S] - Blame information for rev 1765

Details | Compare with Previous | View Log


        .file "reg_round.S"
/*---------------------------------------------------------------------------+
 |  reg_round.S                                                              |
 |                                                                           |
 | Rounding/truncation/etc for FPU basic arithmetic functions.               |
 |                                                                           |
 | Copyright (C) 1993,1995                                                   |
 |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
 |                       Australia.  E-mail billm@jacobi.maths.monash.edu.au |
 |                                                                           |
 | This code has four possible entry points.                                 |
 | The following must be entered by a jmp instruction:                       |
 |   fpu_reg_round, fpu_reg_round_sqrt, and fpu_Arith_exit.                  |
 |                                                                           |
 | The _round_reg entry point is intended to be used by C code.              |
 | From C, call as:                                                          |
 | void round_reg(FPU_REG *arg, unsigned int extent, unsigned int control_w) |
 |                                                                           |
 | For correct "up" and "down" rounding, the argument must have the correct  |
 | sign.                                                                     |
 |                                                                           |
 +---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------+
 | Four entry points.                                                        |
 |                                                                           |
 | Needed by both the fpu_reg_round and fpu_reg_round_sqrt entry points:     |
 |  %eax:%ebx  64 bit significand                                            |
 |  %edx       32 bit extension of the significand                           |
 |  %edi       pointer to an FPU_REG for the result to be stored             |
 |  stack      calling function must have set up a C stack frame and         |
 |             pushed %esi, %edi, and %ebx                                   |
 |                                                                           |
 | Needed just for the fpu_reg_round_sqrt entry point:                       |
 |  %cx  A control word in the same format as the FPU control word.          |
 | Otherwise, PARAM4 must give such a value.                                 |
 |                                                                           |
 |                                                                           |
 | The significand and its extension are assumed to be exact in the          |
 | following sense:                                                          |
 |   If the significand by itself is the exact result then the significand   |
 |   extension (%edx) must contain 0, otherwise the significand extension    |
 |   must be non-zero.                                                       |
 |   If the significand extension is non-zero then the significand is        |
 |   smaller than the magnitude of the correct exact result by an amount     |
 |   greater than zero and less than one ls bit of the significand.          |
 |   The significand extension is only required to have three possible       |
 |   non-zero values:                                                        |
 |       less than 0x80000000  <=> the significand is less than 1/2 an ls    |
 |                                 bit smaller than the magnitude of the     |
 |                                 true exact result.                        |
 |         exactly 0x80000000  <=> the significand is exactly 1/2 an ls bit  |
 |                                 smaller than the magnitude of the true    |
 |                                 exact result.                             |
 |    greater than 0x80000000  <=> the significand is more than 1/2 an ls    |
 |                                 bit smaller than the magnitude of the     |
 |                                 true exact result.                        |
 |                                                                           |
 +---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------+
 |  The code in this module has become quite complex, but it should handle   |
 |  all of the FPU flags which are set at this stage of the basic arithmetic |
 |  computations.                                                            |
 |  There are a few rare cases where the results are not set identically to  |
 |  a real FPU. These require a bit more thought because at this stage the   |
 |  results of the code here appear to be more consistent...                 |
 |  This may be changed in a future version.                                 |
 +---------------------------------------------------------------------------*/
 
 
#include "fpu_emu.h"
#include "exception.h"
#include "control_w.h"
 
/* Flags for FPU_bits_lost */
#define LOST_DOWN       $1
#define LOST_UP         $2
 
/* Flags for FPU_denormal */
#define DENORMAL        $1
#define UNMASKED_UNDERFLOW $2
 
 
#ifndef NON_REENTRANT_FPU
/*      Make the code re-entrant by putting
        local storage on the stack: */
#define FPU_bits_lost   (%esp)
#define FPU_denormal    1(%esp)
 
#else
/*      Not re-entrant, so we can gain speed by putting
        local storage in a static area: */
.data
        .align 2,0
FPU_bits_lost:
        .byte   0
FPU_denormal:
        .byte   0
#endif NON_REENTRANT_FPU
 
 
.text
.globl fpu_reg_round
.globl fpu_reg_round_sqrt
.globl fpu_Arith_exit
 
/* Entry point when called from C */
ENTRY(round_reg)
        pushl   %ebp
        movl    %esp,%ebp
        pushl   %esi
        pushl   %edi
        pushl   %ebx
 
        movl    PARAM1,%edi
        movl    SIGH(%edi),%eax
        movl    SIGL(%edi),%ebx
        movl    PARAM2,%edx
        movl    PARAM3,%ecx
        jmp     fpu_reg_round_sqrt
 
fpu_reg_round:                  /* Normal entry point */
        movl    PARAM4,%ecx
 
fpu_reg_round_sqrt:             /* Entry point from wm_sqrt.S */
 
#ifndef NON_REENTRANT_FPU
        pushl   %ebx            /* adjust the stack pointer */
#endif NON_REENTRANT_FPU
 
#ifdef PARANOID
/* Cannot use this here yet */
/*      orl     %eax,%eax */
/*      jns     L_entry_bugged */
#endif PARANOID
 
        cmpl    EXP_UNDER,EXP(%edi)
        jle     xMake_denorm                    /* The number is a de-normal */
 
        movb    $0,FPU_denormal                 /* 0 -> not a de-normal */
 
xDenorm_done:
        movb    $0,FPU_bits_lost                /* No bits yet lost in rounding */
 
        movl    %ecx,%esi
        andl    CW_PC,%ecx
        cmpl    PR_64_BITS,%ecx
        je      LRound_To_64
 
        cmpl    PR_53_BITS,%ecx
        je      LRound_To_53
 
        cmpl    PR_24_BITS,%ecx
        je      LRound_To_24
 
#ifdef PECULIAR_486
/* With the precision control bits set to 01 "(reserved)", a real 80486
   behaves as if the precision control bits were set to 11 "64 bits" */
        cmpl    PR_RESERVED_BITS,%ecx
        je      LRound_To_64
#ifdef PARANOID
        jmp     L_bugged_denorm_486
#endif PARANOID
#else
#ifdef PARANOID
        jmp     L_bugged_denorm /* There is no bug, just a bad control word */
#endif PARANOID
#endif PECULIAR_486
 
 
/* Round etc to 24 bit precision */
LRound_To_24:
        movl    %esi,%ecx
        andl    CW_RC,%ecx
        cmpl    RC_RND,%ecx
        je      LRound_nearest_24
 
        cmpl    RC_CHOP,%ecx
        je      LCheck_truncate_24
 
        cmpl    RC_UP,%ecx              /* Towards +infinity */
        je      LUp_24
 
        cmpl    RC_DOWN,%ecx            /* Towards -infinity */
        je      LDown_24
 
#ifdef PARANOID
        jmp     L_bugged_round24
#endif PARANOID
 
LUp_24:
        cmpb    SIGN_POS,SIGN(%edi)
        jne     LCheck_truncate_24      /* If negative then  up==truncate */
 
        jmp     LCheck_24_round_up
 
LDown_24:
        cmpb    SIGN_POS,SIGN(%edi)
        je      LCheck_truncate_24      /* If positive then  down==truncate */
 
LCheck_24_round_up:
        movl    %eax,%ecx
        andl    $0x000000ff,%ecx
        orl     %ebx,%ecx
        orl     %edx,%ecx
        jnz     LDo_24_round_up
        jmp     LRe_normalise
 
LRound_nearest_24:
        /* Do rounding of the 24th bit if needed (nearest or even) */
        movl    %eax,%ecx
        andl    $0x000000ff,%ecx
        cmpl    $0x00000080,%ecx
        jc      LCheck_truncate_24      /* less than half, no increment needed */
 
        jne     LGreater_Half_24        /* greater than half, increment needed */
 
        /* Possibly half, we need to check the ls bits */
        orl     %ebx,%ebx
        jnz     LGreater_Half_24        /* greater than half, increment needed */
 
        orl     %edx,%edx
        jnz     LGreater_Half_24        /* greater than half, increment needed */
 
        /* Exactly half, increment only if 24th bit is 1 (round to even) */
        testl   $0x00000100,%eax
        jz      LDo_truncate_24
 
LGreater_Half_24:                       /* Rounding: increment at the 24th bit */
LDo_24_round_up:
        andl    $0xffffff00,%eax        /* Truncate to 24 bits */
        xorl    %ebx,%ebx
        movb    LOST_UP,FPU_bits_lost
        addl    $0x00000100,%eax
        jmp     LCheck_Round_Overflow
 
LCheck_truncate_24:
        movl    %eax,%ecx
        andl    $0x000000ff,%ecx
        orl     %ebx,%ecx
        orl     %edx,%ecx
        jz      LRe_normalise           /* No truncation needed */
 
LDo_truncate_24:
        andl    $0xffffff00,%eax        /* Truncate to 24 bits */
        xorl    %ebx,%ebx
        movb    LOST_DOWN,FPU_bits_lost
        jmp     LRe_normalise
 
 
/* Round etc to 53 bit precision */
LRound_To_53:
        movl    %esi,%ecx
        andl    CW_RC,%ecx
        cmpl    RC_RND,%ecx
        je      LRound_nearest_53
 
        cmpl    RC_CHOP,%ecx
        je      LCheck_truncate_53
 
        cmpl    RC_UP,%ecx              /* Towards +infinity */
        je      LUp_53
 
        cmpl    RC_DOWN,%ecx            /* Towards -infinity */
        je      LDown_53
 
#ifdef PARANOID
        jmp     L_bugged_round53
#endif PARANOID
 
LUp_53:
        cmpb    SIGN_POS,SIGN(%edi)
        jne     LCheck_truncate_53      /* If negative then  up==truncate */
 
        jmp     LCheck_53_round_up
 
LDown_53:
        cmpb    SIGN_POS,SIGN(%edi)
        je      LCheck_truncate_53      /* If positive then  down==truncate */
 
LCheck_53_round_up:
        movl    %ebx,%ecx
        andl    $0x000007ff,%ecx
        orl     %edx,%ecx
        jnz     LDo_53_round_up
        jmp     LRe_normalise
 
LRound_nearest_53:
        /* Do rounding of the 53rd bit if needed (nearest or even) */
        movl    %ebx,%ecx
        andl    $0x000007ff,%ecx
        cmpl    $0x00000400,%ecx
        jc      LCheck_truncate_53      /* less than half, no increment needed */
 
        jnz     LGreater_Half_53        /* greater than half, increment needed */
 
        /* Possibly half, we need to check the ls bits */
        orl     %edx,%edx
        jnz     LGreater_Half_53        /* greater than half, increment needed */
 
        /* Exactly half, increment only if 53rd bit is 1 (round to even) */
        testl   $0x00000800,%ebx
        jz      LTruncate_53
 
LGreater_Half_53:                       /* Rounding: increment at the 53rd bit */
LDo_53_round_up:
        movb    LOST_UP,FPU_bits_lost
        andl    $0xfffff800,%ebx        /* Truncate to 53 bits */
        addl    $0x00000800,%ebx
        adcl    $0,%eax
        jmp     LCheck_Round_Overflow
 
LCheck_truncate_53:
        movl    %ebx,%ecx
        andl    $0x000007ff,%ecx
        orl     %edx,%ecx
        jz      LRe_normalise
 
LTruncate_53:
        movb    LOST_DOWN,FPU_bits_lost
        andl    $0xfffff800,%ebx        /* Truncate to 53 bits */
        jmp     LRe_normalise
 
 
/* Round etc to 64 bit precision */
LRound_To_64:
        movl    %esi,%ecx
        andl    CW_RC,%ecx
        cmpl    RC_RND,%ecx
        je      LRound_nearest_64
 
        cmpl    RC_CHOP,%ecx
        je      LCheck_truncate_64
 
        cmpl    RC_UP,%ecx              /* Towards +infinity */
        je      LUp_64
 
        cmpl    RC_DOWN,%ecx            /* Towards -infinity */
        je      LDown_64
 
#ifdef PARANOID
        jmp     L_bugged_round64
#endif PARANOID
 
LUp_64:
        cmpb    SIGN_POS,SIGN(%edi)
        jne     LCheck_truncate_64      /* If negative then  up==truncate */
 
        orl     %edx,%edx
        jnz     LDo_64_round_up
        jmp     LRe_normalise
 
LDown_64:
        cmpb    SIGN_POS,SIGN(%edi)
        je      LCheck_truncate_64      /* If positive then  down==truncate */
 
        orl     %edx,%edx
        jnz     LDo_64_round_up
        jmp     LRe_normalise
 
LRound_nearest_64:
        cmpl    $0x80000000,%edx
        jc      LCheck_truncate_64
 
        jne     LDo_64_round_up
 
        /* Now test for round-to-even */
        testb   $1,%ebx
        jz      LCheck_truncate_64
 
LDo_64_round_up:
        movb    LOST_UP,FPU_bits_lost
        addl    $1,%ebx
        adcl    $0,%eax
 
LCheck_Round_Overflow:
        jnc     LRe_normalise
 
        /* Overflow, adjust the result (significand to 1.0) */
        rcrl    $1,%eax
        rcrl    $1,%ebx
        incl    EXP(%edi)
        jmp     LRe_normalise
 
LCheck_truncate_64:
        orl     %edx,%edx
        jz      LRe_normalise
 
LTruncate_64:
        movb    LOST_DOWN,FPU_bits_lost
 
LRe_normalise:
        testb   $0xff,FPU_denormal
        jnz     xNormalise_result
 
xL_Normalised:
        cmpb    LOST_UP,FPU_bits_lost
        je      xL_precision_lost_up
 
        cmpb    LOST_DOWN,FPU_bits_lost
        je      xL_precision_lost_down
 
xL_no_precision_loss:
        /* store the result */
        movb    TW_Valid,TAG(%edi)
 
xL_Store_significand:
        movl    %eax,SIGH(%edi)
        movl    %ebx,SIGL(%edi)
 
        xorl    %eax,%eax       /* No errors detected. */
 
        cmpl    EXP_OVER,EXP(%edi)
        jge     L_overflow
 
fpu_reg_round_exit:
#ifndef NON_REENTRANT_FPU
        popl    %ebx            /* adjust the stack pointer */
#endif NON_REENTRANT_FPU
 
fpu_Arith_exit:
        popl    %ebx
        popl    %edi
        popl    %esi
        leave
        ret
 
 
/*
 * Set the FPU status flags to represent precision loss due to
 * round-up.
 */
xL_precision_lost_up:
        push    %eax
        call    SYMBOL_NAME(set_precision_flag_up)
        popl    %eax
        jmp     xL_no_precision_loss
 
/*
 * Set the FPU status flags to represent precision loss due to
 * truncation.
 */
xL_precision_lost_down:
        push    %eax
        call    SYMBOL_NAME(set_precision_flag_down)
        popl    %eax
        jmp     xL_no_precision_loss
 
 
/*
 * The number is a denormal (which might get rounded up to a normal)
 * Shift the number right the required number of bits, which will
 * have to be undone later...
 */
xMake_denorm:
        /* The action to be taken depends upon whether the underflow
           exception is masked */
        testb   CW_Underflow,%cl                /* Underflow mask. */
        jz      xUnmasked_underflow             /* Do not make a denormal. */
 
        movb    DENORMAL,FPU_denormal
 
        pushl   %ecx            /* Save */
        movl    EXP_UNDER+1,%ecx
        subl    EXP(%edi),%ecx
 
        cmpl    $64,%ecx        /* shrd only works for 0..31 bits */
        jnc     xDenorm_shift_more_than_63
 
        cmpl    $32,%ecx        /* shrd only works for 0..31 bits */
        jnc     xDenorm_shift_more_than_32
 
/*
 * We got here without jumps by assuming that the most common requirement
 *   is for a small de-normalising shift.
 * Shift by [1..31] bits
 */
        addl    %ecx,EXP(%edi)
        orl     %edx,%edx       /* extension */
        setne   %ch             /* Save whether %edx is non-zero */
        xorl    %edx,%edx
        shrd    %cl,%ebx,%edx
        shrd    %cl,%eax,%ebx
        shr     %cl,%eax
        orb     %ch,%dl
        popl    %ecx
        jmp     xDenorm_done
 
/* Shift by [32..63] bits */
xDenorm_shift_more_than_32:
        addl    %ecx,EXP(%edi)
        subb    $32,%cl
        orl     %edx,%edx
        setne   %ch
        orb     %ch,%bl
        xorl    %edx,%edx
        shrd    %cl,%ebx,%edx
        shrd    %cl,%eax,%ebx
        shr     %cl,%eax
        orl     %edx,%edx               /* test these 32 bits */
        setne   %cl
        orb     %ch,%bl
        orb     %cl,%bl
        movl    %ebx,%edx
        movl    %eax,%ebx
        xorl    %eax,%eax
        popl    %ecx
        jmp     xDenorm_done
 
/* Shift by [64..) bits */
xDenorm_shift_more_than_63:
        cmpl    $64,%ecx
        jne     xDenorm_shift_more_than_64
 
/* Exactly 64 bit shift */
        addl    %ecx,EXP(%edi)
        xorl    %ecx,%ecx
        orl     %edx,%edx
        setne   %cl
        orl     %ebx,%ebx
        setne   %ch
        orb     %ch,%cl
        orb     %cl,%al
        movl    %eax,%edx
        xorl    %eax,%eax
        xorl    %ebx,%ebx
        popl    %ecx
        jmp     xDenorm_done
 
xDenorm_shift_more_than_64:
        movl    EXP_UNDER+1,EXP(%edi)
/* This is easy, %eax must be non-zero, so.. */
        movl    $1,%edx
        xorl    %eax,%eax
        xorl    %ebx,%ebx
        popl    %ecx
        jmp     xDenorm_done
 
 
xUnmasked_underflow:
        movb    UNMASKED_UNDERFLOW,FPU_denormal
        jmp     xDenorm_done
 
 
/* Undo the de-normalisation. */
xNormalise_result:
        cmpb    UNMASKED_UNDERFLOW,FPU_denormal
        je      xSignal_underflow
 
/* The number must be a denormal if we got here. */
#ifdef PARANOID
        /* But check it... just in case. */
        cmpl    EXP_UNDER+1,EXP(%edi)
        jne     L_norm_bugged
#endif PARANOID
 
#ifdef PECULIAR_486
        /*
         * This implements a special feature of 80486 behaviour.
         * Underflow will be signalled even if the number is
         * not a denormal after rounding.
         * This difference occurs only for masked underflow, and not
         * in the unmasked case.
         * Actual 80486 behaviour differs from this in some circumstances.
         */
        orl     %eax,%eax               /* ms bits */
        js      LNormalise_shift_done   /* Will be masked underflow */
#endif PECULIAR_486
 
        orl     %eax,%eax               /* ms bits */
        js      xL_Normalised           /* No longer a denormal */
 
        jnz     LNormalise_shift_up_to_31       /* Shift left 0 - 31 bits */
 
        orl     %ebx,%ebx
        jz      L_underflow_to_zero     /* The contents are zero */
 
/* Shift left 32 - 63 bits */
        movl    %ebx,%eax
        xorl    %ebx,%ebx
        subl    $32,EXP(%edi)
 
LNormalise_shift_up_to_31:
        bsrl    %eax,%ecx       /* get the required shift in %ecx */
        subl    $31,%ecx
        negl    %ecx
        shld    %cl,%ebx,%eax
        shl     %cl,%ebx
        subl    %ecx,EXP(%edi)
 
LNormalise_shift_done:
        testb   $0xff,FPU_bits_lost     /* bits lost == underflow */
        jz      xL_Normalised
 
        /* There must be a masked underflow */
        push    %eax
        pushl   EX_Underflow
        call    SYMBOL_NAME(exception)
        popl    %eax
        popl    %eax
        jmp     xL_Normalised
 
 
/*
 * The operations resulted in a number too small to represent.
 * Masked response.
 */
L_underflow_to_zero:
        push    %eax
        call    SYMBOL_NAME(set_precision_flag_down)
        popl    %eax
 
        push    %eax
        pushl   EX_Underflow
        call    SYMBOL_NAME(exception)
        popl    %eax
        popl    %eax
 
/* Reduce the exponent to EXP_UNDER */
        movl    EXP_UNDER,EXP(%edi)
        movb    TW_Zero,TAG(%edi)
        jmp     xL_Store_significand
 
 
/* The operations resulted in a number too large to represent. */
L_overflow:
        push    %edi
        call    SYMBOL_NAME(arith_overflow)
        pop     %edi
        jmp     fpu_reg_round_exit
 
 
xSignal_underflow:
        /* The number may have been changed to a non-denormal */
        /* by the rounding operations. */
        cmpl    EXP_UNDER,EXP(%edi)
        jle     xDo_unmasked_underflow
 
        jmp     xL_Normalised
 
xDo_unmasked_underflow:
        /* Increase the exponent by the magic number */
        addl    $(3*(1<<13)),EXP(%edi)
        push    %eax
        pushl   EX_Underflow
        call    EXCEPTION
        popl    %eax
        popl    %eax
        jmp     xL_Normalised
 
 
#ifdef PARANOID
#ifdef PECULIAR_486
L_bugged_denorm_486:
        pushl   EX_INTERNAL|0x236
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
#else
L_bugged_denorm:
        pushl   EX_INTERNAL|0x230
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
#endif PECULIAR_486
 
L_bugged_round24:
        pushl   EX_INTERNAL|0x231
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
 
L_bugged_round53:
        pushl   EX_INTERNAL|0x232
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
 
L_bugged_round64:
        pushl   EX_INTERNAL|0x233
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
 
L_norm_bugged:
        pushl   EX_INTERNAL|0x234
        call    EXCEPTION
        popl    %ebx
        jmp     L_exception_exit
 
L_entry_bugged:
        pushl   EX_INTERNAL|0x235
        call    EXCEPTION
        popl    %ebx
L_exception_exit:
        mov     $1,%eax
        jmp     fpu_reg_round_exit
#endif PARANOID

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [arch/] [i386/] [math-emu/] [reg_round.S] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1623	jcastillo	`.file "reg_round.S"`
2			`/*---------------------------------------------------------------------------+`
3			`\| reg_round.S \|`
4			`\| \|`
5			`\| Rounding/truncation/etc for FPU basic arithmetic functions. \|`
6			`\| \|`
7			`\| Copyright (C) 1993,1995 \|`
8			`\| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, \|`
9			`\| Australia. E-mail billm@jacobi.maths.monash.edu.au \|`
10			`\| \|`
11			`\| This code has four possible entry points. \|`
12			`\| The following must be entered by a jmp instruction: \|`
13			`\| fpu_reg_round, fpu_reg_round_sqrt, and fpu_Arith_exit. \|`
14			`\| \|`
15			`\| The _round_reg entry point is intended to be used by C code. \|`
16			`\| From C, call as: \|`
17			`\| void round_reg(FPU_REG *arg, unsigned int extent, unsigned int control_w) \|`
18			`\| \|`
19			`\| For correct "up" and "down" rounding, the argument must have the correct \|`
20			`\| sign. \|`
21			`\| \|`
22			`+---------------------------------------------------------------------------*/`
23
24			`/*---------------------------------------------------------------------------+`
25			`\| Four entry points. \|`
26			`\| \|`
27			`\| Needed by both the fpu_reg_round and fpu_reg_round_sqrt entry points: \|`
28			`\| %eax:%ebx 64 bit significand \|`
29			`\| %edx 32 bit extension of the significand \|`
30			`\| %edi pointer to an FPU_REG for the result to be stored \|`
31			`\| stack calling function must have set up a C stack frame and \|`
32			`\| pushed %esi, %edi, and %ebx \|`
33			`\| \|`
34			`\| Needed just for the fpu_reg_round_sqrt entry point: \|`
35			`\| %cx A control word in the same format as the FPU control word. \|`
36			`\| Otherwise, PARAM4 must give such a value. \|`
37			`\| \|`
38			`\| \|`
39			`\| The significand and its extension are assumed to be exact in the \|`
40			`\| following sense: \|`
41			`\| If the significand by itself is the exact result then the significand \|`
42			`\| extension (%edx) must contain 0, otherwise the significand extension \|`
43			`\| must be non-zero. \|`
44			`\| If the significand extension is non-zero then the significand is \|`
45			`\| smaller than the magnitude of the correct exact result by an amount \|`
46			`\| greater than zero and less than one ls bit of the significand. \|`
47			`\| The significand extension is only required to have three possible \|`
48			`\| non-zero values: \|`
49			`\| less than 0x80000000 <=> the significand is less than 1/2 an ls \|`
50			`\| bit smaller than the magnitude of the \|`
51			`\| true exact result. \|`
52			`\| exactly 0x80000000 <=> the significand is exactly 1/2 an ls bit \|`
53			`\| smaller than the magnitude of the true \|`
54			`\| exact result. \|`
55			`\| greater than 0x80000000 <=> the significand is more than 1/2 an ls \|`
56			`\| bit smaller than the magnitude of the \|`
57			`\| true exact result. \|`
58			`\| \|`
59			`+---------------------------------------------------------------------------*/`
60
61			`/*---------------------------------------------------------------------------+`
62			`\| The code in this module has become quite complex, but it should handle \|`
63			`\| all of the FPU flags which are set at this stage of the basic arithmetic \|`
64			`\| computations. \|`
65			`\| There are a few rare cases where the results are not set identically to \|`
66			`\| a real FPU. These require a bit more thought because at this stage the \|`
67			`\| results of the code here appear to be more consistent... \|`
68			`\| This may be changed in a future version. \|`
69			`+---------------------------------------------------------------------------*/`
70
71
72			`#include "fpu_emu.h"`
73			`#include "exception.h"`
74			`#include "control_w.h"`
75
76			`/* Flags for FPU_bits_lost */`
77			`#define LOST_DOWN $1`
78			`#define LOST_UP $2`
79
80			`/* Flags for FPU_denormal */`
81			`#define DENORMAL $1`
82			`#define UNMASKED_UNDERFLOW $2`
83
84
85			`#ifndef NON_REENTRANT_FPU`
86			`/* Make the code re-entrant by putting`
87			`local storage on the stack: */`
88			`#define FPU_bits_lost (%esp)`
89			`#define FPU_denormal 1(%esp)`
90
91			`#else`
92			`/* Not re-entrant, so we can gain speed by putting`
93			`local storage in a static area: */`
94			`.data`
95			`.align 2,0`
96			`FPU_bits_lost:`
97			`.byte 0`
98			`FPU_denormal:`
99			`.byte 0`
100			`#endif NON_REENTRANT_FPU`
101
102
103			`.text`
104			`.globl fpu_reg_round`
105			`.globl fpu_reg_round_sqrt`
106			`.globl fpu_Arith_exit`
107
108			`/* Entry point when called from C */`
109			`ENTRY(round_reg)`
110			`pushl %ebp`
111			`movl %esp,%ebp`
112			`pushl %esi`
113			`pushl %edi`
114			`pushl %ebx`
115
116			`movl PARAM1,%edi`
117			`movl SIGH(%edi),%eax`
118			`movl SIGL(%edi),%ebx`
119			`movl PARAM2,%edx`
120			`movl PARAM3,%ecx`
121			`jmp fpu_reg_round_sqrt`
122
123			`fpu_reg_round: /* Normal entry point */`
124			`movl PARAM4,%ecx`
125
126			`fpu_reg_round_sqrt: /* Entry point from wm_sqrt.S */`
127
128			`#ifndef NON_REENTRANT_FPU`
129			`pushl %ebx /* adjust the stack pointer */`
130			`#endif NON_REENTRANT_FPU`
131
132			`#ifdef PARANOID`
133			`/* Cannot use this here yet */`
134			`/* orl %eax,%eax */`
135			`/* jns L_entry_bugged */`
136			`#endif PARANOID`
137
138			`cmpl EXP_UNDER,EXP(%edi)`
139			`jle xMake_denorm /* The number is a de-normal */`
140
141			`movb $0,FPU_denormal /* 0 -> not a de-normal */`
142
143			`xDenorm_done:`
144			`movb $0,FPU_bits_lost /* No bits yet lost in rounding */`
145
146			`movl %ecx,%esi`
147			`andl CW_PC,%ecx`
148			`cmpl PR_64_BITS,%ecx`
149			`je LRound_To_64`
150
151			`cmpl PR_53_BITS,%ecx`
152			`je LRound_To_53`
153
154			`cmpl PR_24_BITS,%ecx`
155			`je LRound_To_24`
156
157			`#ifdef PECULIAR_486`
158			`/* With the precision control bits set to 01 "(reserved)", a real 80486`
159			`behaves as if the precision control bits were set to 11 "64 bits" */`
160			`cmpl PR_RESERVED_BITS,%ecx`
161			`je LRound_To_64`
162			`#ifdef PARANOID`
163			`jmp L_bugged_denorm_486`
164			`#endif PARANOID`
165			`#else`
166			`#ifdef PARANOID`
167			`jmp L_bugged_denorm /* There is no bug, just a bad control word */`
168			`#endif PARANOID`
169			`#endif PECULIAR_486`
170
171
172			`/* Round etc to 24 bit precision */`
173			`LRound_To_24:`
174			`movl %esi,%ecx`
175			`andl CW_RC,%ecx`
176			`cmpl RC_RND,%ecx`
177			`je LRound_nearest_24`
178
179			`cmpl RC_CHOP,%ecx`
180			`je LCheck_truncate_24`
181
182			`cmpl RC_UP,%ecx /* Towards +infinity */`
183			`je LUp_24`
184
185			`cmpl RC_DOWN,%ecx /* Towards -infinity */`
186			`je LDown_24`
187
188			`#ifdef PARANOID`
189			`jmp L_bugged_round24`
190			`#endif PARANOID`
191
192			`LUp_24:`
193			`cmpb SIGN_POS,SIGN(%edi)`
194			`jne LCheck_truncate_24 /* If negative then up==truncate */`
195
196			`jmp LCheck_24_round_up`
197
198			`LDown_24:`
199			`cmpb SIGN_POS,SIGN(%edi)`
200			`je LCheck_truncate_24 /* If positive then down==truncate */`
201
202			`LCheck_24_round_up:`
203			`movl %eax,%ecx`
204			`andl $0x000000ff,%ecx`
205			`orl %ebx,%ecx`
206			`orl %edx,%ecx`
207			`jnz LDo_24_round_up`
208			`jmp LRe_normalise`
209
210			`LRound_nearest_24:`
211			`/* Do rounding of the 24th bit if needed (nearest or even) */`
212			`movl %eax,%ecx`
213			`andl $0x000000ff,%ecx`
214			`cmpl $0x00000080,%ecx`
215			`jc LCheck_truncate_24 /* less than half, no increment needed */`
216
217			`jne LGreater_Half_24 /* greater than half, increment needed */`
218
219			`/* Possibly half, we need to check the ls bits */`
220			`orl %ebx,%ebx`
221			`jnz LGreater_Half_24 /* greater than half, increment needed */`
222
223			`orl %edx,%edx`
224			`jnz LGreater_Half_24 /* greater than half, increment needed */`
225
226			`/* Exactly half, increment only if 24th bit is 1 (round to even) */`
227			`testl $0x00000100,%eax`
228			`jz LDo_truncate_24`
229
230			`LGreater_Half_24: /* Rounding: increment at the 24th bit */`
231			`LDo_24_round_up:`
232			`andl $0xffffff00,%eax /* Truncate to 24 bits */`
233			`xorl %ebx,%ebx`
234			`movb LOST_UP,FPU_bits_lost`
235			`addl $0x00000100,%eax`
236			`jmp LCheck_Round_Overflow`
237
238			`LCheck_truncate_24:`
239			`movl %eax,%ecx`
240			`andl $0x000000ff,%ecx`
241			`orl %ebx,%ecx`
242			`orl %edx,%ecx`
243			`jz LRe_normalise /* No truncation needed */`
244
245			`LDo_truncate_24:`
246			`andl $0xffffff00,%eax /* Truncate to 24 bits */`
247			`xorl %ebx,%ebx`
248			`movb LOST_DOWN,FPU_bits_lost`
249			`jmp LRe_normalise`
250
251
252			`/* Round etc to 53 bit precision */`
253			`LRound_To_53:`
254			`movl %esi,%ecx`
255			`andl CW_RC,%ecx`
256			`cmpl RC_RND,%ecx`
257			`je LRound_nearest_53`
258
259			`cmpl RC_CHOP,%ecx`
260			`je LCheck_truncate_53`
261
262			`cmpl RC_UP,%ecx /* Towards +infinity */`
263			`je LUp_53`
264
265			`cmpl RC_DOWN,%ecx /* Towards -infinity */`
266			`je LDown_53`
267
268			`#ifdef PARANOID`
269			`jmp L_bugged_round53`
270			`#endif PARANOID`
271
272			`LUp_53:`
273			`cmpb SIGN_POS,SIGN(%edi)`
274			`jne LCheck_truncate_53 /* If negative then up==truncate */`
275
276			`jmp LCheck_53_round_up`
277
278			`LDown_53:`
279			`cmpb SIGN_POS,SIGN(%edi)`
280			`je LCheck_truncate_53 /* If positive then down==truncate */`
281
282			`LCheck_53_round_up:`
283			`movl %ebx,%ecx`
284			`andl $0x000007ff,%ecx`
285			`orl %edx,%ecx`
286			`jnz LDo_53_round_up`
287			`jmp LRe_normalise`
288
289			`LRound_nearest_53:`
290			`/* Do rounding of the 53rd bit if needed (nearest or even) */`
291			`movl %ebx,%ecx`
292			`andl $0x000007ff,%ecx`
293			`cmpl $0x00000400,%ecx`
294			`jc LCheck_truncate_53 /* less than half, no increment needed */`
295
296			`jnz LGreater_Half_53 /* greater than half, increment needed */`
297
298			`/* Possibly half, we need to check the ls bits */`
299			`orl %edx,%edx`
300			`jnz LGreater_Half_53 /* greater than half, increment needed */`
301
302			`/* Exactly half, increment only if 53rd bit is 1 (round to even) */`
303			`testl $0x00000800,%ebx`
304			`jz LTruncate_53`
305
306			`LGreater_Half_53: /* Rounding: increment at the 53rd bit */`
307			`LDo_53_round_up:`
308			`movb LOST_UP,FPU_bits_lost`
309			`andl $0xfffff800,%ebx /* Truncate to 53 bits */`
310			`addl $0x00000800,%ebx`
311			`adcl $0,%eax`
312			`jmp LCheck_Round_Overflow`
313
314			`LCheck_truncate_53:`
315			`movl %ebx,%ecx`
316			`andl $0x000007ff,%ecx`
317			`orl %edx,%ecx`
318			`jz LRe_normalise`
319
320			`LTruncate_53:`
321			`movb LOST_DOWN,FPU_bits_lost`
322			`andl $0xfffff800,%ebx /* Truncate to 53 bits */`
323			`jmp LRe_normalise`
324
325
326			`/* Round etc to 64 bit precision */`
327			`LRound_To_64:`
328			`movl %esi,%ecx`
329			`andl CW_RC,%ecx`
330			`cmpl RC_RND,%ecx`
331			`je LRound_nearest_64`
332
333			`cmpl RC_CHOP,%ecx`
334			`je LCheck_truncate_64`
335
336			`cmpl RC_UP,%ecx /* Towards +infinity */`
337			`je LUp_64`
338
339			`cmpl RC_DOWN,%ecx /* Towards -infinity */`
340			`je LDown_64`
341
342			`#ifdef PARANOID`
343			`jmp L_bugged_round64`
344			`#endif PARANOID`
345
346			`LUp_64:`
347			`cmpb SIGN_POS,SIGN(%edi)`
348			`jne LCheck_truncate_64 /* If negative then up==truncate */`
349
350			`orl %edx,%edx`
351			`jnz LDo_64_round_up`
352			`jmp LRe_normalise`
353
354			`LDown_64:`
355			`cmpb SIGN_POS,SIGN(%edi)`
356			`je LCheck_truncate_64 /* If positive then down==truncate */`
357
358			`orl %edx,%edx`
359			`jnz LDo_64_round_up`
360			`jmp LRe_normalise`
361
362			`LRound_nearest_64:`
363			`cmpl $0x80000000,%edx`
364			`jc LCheck_truncate_64`
365
366			`jne LDo_64_round_up`
367
368			`/* Now test for round-to-even */`
369			`testb $1,%ebx`
370			`jz LCheck_truncate_64`
371
372			`LDo_64_round_up:`
373			`movb LOST_UP,FPU_bits_lost`
374			`addl $1,%ebx`
375			`adcl $0,%eax`
376
377			`LCheck_Round_Overflow:`
378			`jnc LRe_normalise`
379
380			`/* Overflow, adjust the result (significand to 1.0) */`
381			`rcrl $1,%eax`
382			`rcrl $1,%ebx`
383			`incl EXP(%edi)`
384			`jmp LRe_normalise`
385
386			`LCheck_truncate_64:`
387			`orl %edx,%edx`
388			`jz LRe_normalise`
389
390			`LTruncate_64:`
391			`movb LOST_DOWN,FPU_bits_lost`
392
393			`LRe_normalise:`
394			`testb $0xff,FPU_denormal`
395			`jnz xNormalise_result`
396
397			`xL_Normalised:`
398			`cmpb LOST_UP,FPU_bits_lost`
399			`je xL_precision_lost_up`
400
401			`cmpb LOST_DOWN,FPU_bits_lost`
402			`je xL_precision_lost_down`
403
404			`xL_no_precision_loss:`
405			`/* store the result */`
406			`movb TW_Valid,TAG(%edi)`
407
408			`xL_Store_significand:`
409			`movl %eax,SIGH(%edi)`
410			`movl %ebx,SIGL(%edi)`
411
412			`xorl %eax,%eax /* No errors detected. */`
413
414			`cmpl EXP_OVER,EXP(%edi)`
415			`jge L_overflow`
416
417			`fpu_reg_round_exit:`
418			`#ifndef NON_REENTRANT_FPU`
419			`popl %ebx /* adjust the stack pointer */`
420			`#endif NON_REENTRANT_FPU`
421
422			`fpu_Arith_exit:`
423			`popl %ebx`
424			`popl %edi`
425			`popl %esi`
426			`leave`
427			`ret`
428
429
430			`/*`
431			`* Set the FPU status flags to represent precision loss due to`
432			`* round-up.`
433			`*/`
434			`xL_precision_lost_up:`
435			`push %eax`
436			`call SYMBOL_NAME(set_precision_flag_up)`
437			`popl %eax`
438			`jmp xL_no_precision_loss`
439
440			`/*`
441			`* Set the FPU status flags to represent precision loss due to`
442			`* truncation.`
443			`*/`
444			`xL_precision_lost_down:`
445			`push %eax`
446			`call SYMBOL_NAME(set_precision_flag_down)`
447			`popl %eax`
448			`jmp xL_no_precision_loss`
449
450
451			`/*`
452			`* The number is a denormal (which might get rounded up to a normal)`
453			`* Shift the number right the required number of bits, which will`
454			`* have to be undone later...`
455			`*/`
456			`xMake_denorm:`
457			`/* The action to be taken depends upon whether the underflow`
458			`exception is masked */`
459			`testb CW_Underflow,%cl /* Underflow mask. */`
460			`jz xUnmasked_underflow /* Do not make a denormal. */`
461
462			`movb DENORMAL,FPU_denormal`
463
464			`pushl %ecx /* Save */`
465			`movl EXP_UNDER+1,%ecx`
466			`subl EXP(%edi),%ecx`
467
468			`cmpl $64,%ecx /* shrd only works for 0..31 bits */`
469			`jnc xDenorm_shift_more_than_63`
470
471			`cmpl $32,%ecx /* shrd only works for 0..31 bits */`
472			`jnc xDenorm_shift_more_than_32`
473
474			`/*`
475			`* We got here without jumps by assuming that the most common requirement`
476			`* is for a small de-normalising shift.`
477			`* Shift by [1..31] bits`
478			`*/`
479			`addl %ecx,EXP(%edi)`
480			`orl %edx,%edx /* extension */`
481			`setne %ch /* Save whether %edx is non-zero */`
482			`xorl %edx,%edx`
483			`shrd %cl,%ebx,%edx`
484			`shrd %cl,%eax,%ebx`
485			`shr %cl,%eax`
486			`orb %ch,%dl`
487			`popl %ecx`
488			`jmp xDenorm_done`
489
490			`/* Shift by [32..63] bits */`
491			`xDenorm_shift_more_than_32:`
492			`addl %ecx,EXP(%edi)`
493			`subb $32,%cl`
494			`orl %edx,%edx`
495			`setne %ch`
496			`orb %ch,%bl`
497			`xorl %edx,%edx`
498			`shrd %cl,%ebx,%edx`
499			`shrd %cl,%eax,%ebx`
500			`shr %cl,%eax`
501			`orl %edx,%edx /* test these 32 bits */`
502			`setne %cl`
503			`orb %ch,%bl`
504			`orb %cl,%bl`
505			`movl %ebx,%edx`
506			`movl %eax,%ebx`
507			`xorl %eax,%eax`
508			`popl %ecx`
509			`jmp xDenorm_done`
510
511			`/* Shift by [64..) bits */`
512			`xDenorm_shift_more_than_63:`
513			`cmpl $64,%ecx`
514			`jne xDenorm_shift_more_than_64`
515
516			`/* Exactly 64 bit shift */`
517			`addl %ecx,EXP(%edi)`
518			`xorl %ecx,%ecx`
519			`orl %edx,%edx`
520			`setne %cl`
521			`orl %ebx,%ebx`
522			`setne %ch`
523			`orb %ch,%cl`
524			`orb %cl,%al`
525			`movl %eax,%edx`
526			`xorl %eax,%eax`
527			`xorl %ebx,%ebx`
528			`popl %ecx`
529			`jmp xDenorm_done`
530
531			`xDenorm_shift_more_than_64:`
532			`movl EXP_UNDER+1,EXP(%edi)`
533			`/* This is easy, %eax must be non-zero, so.. */`
534			`movl $1,%edx`
535			`xorl %eax,%eax`
536			`xorl %ebx,%ebx`
537			`popl %ecx`
538			`jmp xDenorm_done`
539
540
541			`xUnmasked_underflow:`
542			`movb UNMASKED_UNDERFLOW,FPU_denormal`
543			`jmp xDenorm_done`
544
545
546			`/* Undo the de-normalisation. */`
547			`xNormalise_result:`
548			`cmpb UNMASKED_UNDERFLOW,FPU_denormal`
549			`je xSignal_underflow`
550
551			`/* The number must be a denormal if we got here. */`
552			`#ifdef PARANOID`
553			`/* But check it... just in case. */`
554			`cmpl EXP_UNDER+1,EXP(%edi)`
555			`jne L_norm_bugged`
556			`#endif PARANOID`
557
558			`#ifdef PECULIAR_486`
559			`/*`
560			`* This implements a special feature of 80486 behaviour.`
561			`* Underflow will be signalled even if the number is`
562			`* not a denormal after rounding.`
563			`* This difference occurs only for masked underflow, and not`
564			`* in the unmasked case.`
565			`* Actual 80486 behaviour differs from this in some circumstances.`
566			`*/`
567			`orl %eax,%eax /* ms bits */`
568			`js LNormalise_shift_done /* Will be masked underflow */`
569			`#endif PECULIAR_486`
570
571			`orl %eax,%eax /* ms bits */`
572			`js xL_Normalised /* No longer a denormal */`
573
574			`jnz LNormalise_shift_up_to_31 /* Shift left 0 - 31 bits */`
575
576			`orl %ebx,%ebx`
577			`jz L_underflow_to_zero /* The contents are zero */`
578
579			`/* Shift left 32 - 63 bits */`
580			`movl %ebx,%eax`
581			`xorl %ebx,%ebx`
582			`subl $32,EXP(%edi)`
583
584			`LNormalise_shift_up_to_31:`
585			`bsrl %eax,%ecx /* get the required shift in %ecx */`
586			`subl $31,%ecx`
587			`negl %ecx`
588			`shld %cl,%ebx,%eax`
589			`shl %cl,%ebx`
590			`subl %ecx,EXP(%edi)`
591
592			`LNormalise_shift_done:`
593			`testb $0xff,FPU_bits_lost /* bits lost == underflow */`
594			`jz xL_Normalised`
595
596			`/* There must be a masked underflow */`
597			`push %eax`
598			`pushl EX_Underflow`
599			`call SYMBOL_NAME(exception)`
600			`popl %eax`
601			`popl %eax`
602			`jmp xL_Normalised`
603
604
605			`/*`
606			`* The operations resulted in a number too small to represent.`
607			`* Masked response.`
608			`*/`
609			`L_underflow_to_zero:`
610			`push %eax`
611			`call SYMBOL_NAME(set_precision_flag_down)`
612			`popl %eax`
613
614			`push %eax`
615			`pushl EX_Underflow`
616			`call SYMBOL_NAME(exception)`
617			`popl %eax`
618			`popl %eax`
619
620			`/* Reduce the exponent to EXP_UNDER */`
621			`movl EXP_UNDER,EXP(%edi)`
622			`movb TW_Zero,TAG(%edi)`
623			`jmp xL_Store_significand`
624
625
626			`/* The operations resulted in a number too large to represent. */`
627			`L_overflow:`
628			`push %edi`
629			`call SYMBOL_NAME(arith_overflow)`
630			`pop %edi`
631			`jmp fpu_reg_round_exit`
632
633
634			`xSignal_underflow:`
635			`/* The number may have been changed to a non-denormal */`
636			`/* by the rounding operations. */`
637			`cmpl EXP_UNDER,EXP(%edi)`
638			`jle xDo_unmasked_underflow`
639
640			`jmp xL_Normalised`
641
642			`xDo_unmasked_underflow:`
643			`/* Increase the exponent by the magic number */`
644			`addl $(3*(1<<13)),EXP(%edi)`
645			`push %eax`
646			`pushl EX_Underflow`
647			`call EXCEPTION`
648			`popl %eax`
649			`popl %eax`
650			`jmp xL_Normalised`
651
652
653			`#ifdef PARANOID`
654			`#ifdef PECULIAR_486`
655			`L_bugged_denorm_486:`
656			`pushl EX_INTERNAL\|0x236`
657			`call EXCEPTION`
658			`popl %ebx`
659			`jmp L_exception_exit`
660			`#else`
661			`L_bugged_denorm:`
662			`pushl EX_INTERNAL\|0x230`
663			`call EXCEPTION`
664			`popl %ebx`
665			`jmp L_exception_exit`
666			`#endif PECULIAR_486`
667
668			`L_bugged_round24:`
669			`pushl EX_INTERNAL\|0x231`
670			`call EXCEPTION`
671			`popl %ebx`
672			`jmp L_exception_exit`
673
674			`L_bugged_round53:`
675			`pushl EX_INTERNAL\|0x232`
676			`call EXCEPTION`
677			`popl %ebx`
678			`jmp L_exception_exit`
679
680			`L_bugged_round64:`
681			`pushl EX_INTERNAL\|0x233`
682			`call EXCEPTION`
683			`popl %ebx`
684			`jmp L_exception_exit`
685
686			`L_norm_bugged:`
687			`pushl EX_INTERNAL\|0x234`
688			`call EXCEPTION`
689			`popl %ebx`
690			`jmp L_exception_exit`
691
692			`L_entry_bugged:`
693			`pushl EX_INTERNAL\|0x235`
694			`call EXCEPTION`
695			`popl %ebx`
696			`L_exception_exit:`
697			`mov $1,%eax`
698			`jmp fpu_reg_round_exit`
699			`#endif PARANOID`