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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [i386/] [math-emu/] [reg_u_div.S] - Blame information for rev 1765

Details | Compare with Previous | View Log


        .file   "reg_u_div.S"
/*---------------------------------------------------------------------------+
 |  reg_u_div.S                                                              |
 |                                                                           |
 | Divide one FPU_REG by another and put the result in a destination FPU_REG.|
 |                                                                           |
 | Copyright (C) 1992,1993,1995,1997                                         |
 |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
 |                  E-mail   billm@suburbia.net                              |
 |                                                                           |
 |                                                                           |
 +---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------+
 | Call from C as:                                                           |
 |    int FPU_u_div(FPU_REG *a, FPU_REG *b, FPU_REG *dest,                   |
 |                unsigned int control_word, char *sign)                     |
 |                                                                           |
 |  Does not compute the destination exponent, but does adjust it.           |
 |                                                                           |
 |    Return value is the tag of the answer, or-ed with FPU_Exception if     |
 |    one was raised, or -1 on internal error.                               |
 +---------------------------------------------------------------------------*/
 
#include "exception.h"
#include "fpu_emu.h"
#include "control_w.h"
 
 
/* #define      dSIGL(x)        (x) */
/* #define      dSIGH(x)        4(x) */
 
 
#ifndef NON_REENTRANT_FPU
/*
        Local storage on the stack:
        Result:         FPU_accum_3:FPU_accum_2:FPU_accum_1:FPU_accum_0
        Overflow flag:  ovfl_flag
 */
#define FPU_accum_3     -4(%ebp)
#define FPU_accum_2     -8(%ebp)
#define FPU_accum_1     -12(%ebp)
#define FPU_accum_0     -16(%ebp)
#define FPU_result_1    -20(%ebp)
#define FPU_result_2    -24(%ebp)
#define FPU_ovfl_flag   -28(%ebp)
 
#else
.data
/*
        Local storage in a static area:
        Result:         FPU_accum_3:FPU_accum_2:FPU_accum_1:FPU_accum_0
        Overflow flag:  ovfl_flag
 */
        .align 4,0
FPU_accum_3:
        .long   0
FPU_accum_2:
        .long   0
FPU_accum_1:
        .long   0
FPU_accum_0:
        .long   0
FPU_result_1:
        .long   0
FPU_result_2:
        .long   0
FPU_ovfl_flag:
        .byte   0
#endif /* NON_REENTRANT_FPU */
 
#define REGA    PARAM1
#define REGB    PARAM2
#define DEST    PARAM3
 
.text
ENTRY(FPU_u_div)
        pushl   %ebp
        movl    %esp,%ebp
#ifndef NON_REENTRANT_FPU
        subl    $28,%esp
#endif /* NON_REENTRANT_FPU */
 
        pushl   %esi
        pushl   %edi
        pushl   %ebx
 
        movl    REGA,%esi
        movl    REGB,%ebx
        movl    DEST,%edi
 
        movswl  EXP(%esi),%edx
        movswl  EXP(%ebx),%eax
        subl    %eax,%edx
        addl    EXP_BIAS,%edx
 
        /* A denormal and a large number can cause an exponent underflow */
        cmpl    EXP_WAY_UNDER,%edx
        jg      xExp_not_underflow
 
        /* Set to a really low value allow correct handling */
        movl    EXP_WAY_UNDER,%edx
 
xExp_not_underflow:
 
        movw    %dx,EXP(%edi)
 
#ifdef PARANOID
/*      testl   $0x80000000, SIGH(%esi) // Dividend */
/*      je      L_bugged */
        testl   $0x80000000, SIGH(%ebx) /* Divisor */
        je      L_bugged
#endif /* PARANOID */
 
/* Check if the divisor can be treated as having just 32 bits */
        cmpl    $0,SIGL(%ebx)
        jnz     L_Full_Division /* Can't do a quick divide */
 
/* We should be able to zip through the division here */
        movl    SIGH(%ebx),%ecx /* The divisor */
        movl    SIGH(%esi),%edx /* Dividend */
        movl    SIGL(%esi),%eax /* Dividend */
 
        cmpl    %ecx,%edx
        setaeb  FPU_ovfl_flag   /* Keep a record */
        jb      L_no_adjust
 
        subl    %ecx,%edx       /* Prevent the overflow */
 
L_no_adjust:
        /* Divide the 64 bit number by the 32 bit denominator */
        divl    %ecx
        movl    %eax,FPU_result_2
 
        /* Work on the remainder of the first division */
        xorl    %eax,%eax
        divl    %ecx
        movl    %eax,FPU_result_1
 
        /* Work on the remainder of the 64 bit division */
        xorl    %eax,%eax
        divl    %ecx
 
        testb   $255,FPU_ovfl_flag      /* was the num > denom ? */
        je      L_no_overflow
 
        /* Do the shifting here */
        /* increase the exponent */
        incw    EXP(%edi)
 
        /* shift the mantissa right one bit */
        stc                     /* To set the ms bit */
        rcrl    FPU_result_2
        rcrl    FPU_result_1
        rcrl    %eax
 
L_no_overflow:
        jmp     LRound_precision        /* Do the rounding as required */
 
 
/*---------------------------------------------------------------------------+
 |  Divide:   Return  arg1/arg2 to arg3.                                     |
 |                                                                           |
 |  This routine does not use the exponents of arg1 and arg2, but does       |
 |  adjust the exponent of arg3.                                             |
 |                                                                           |
 |  The maximum returned value is (ignoring exponents)                       |
 |               .ffffffff ffffffff                                          |
 |               ------------------  =  1.ffffffff fffffffe                  |
 |               .80000000 00000000                                          |
 | and the minimum is                                                        |
 |               .80000000 00000000                                          |
 |               ------------------  =  .80000000 00000001   (rounded)       |
 |               .ffffffff ffffffff                                          |
 |                                                                           |
 +---------------------------------------------------------------------------*/
 
 
L_Full_Division:
        /* Save extended dividend in local register */
        movl    SIGL(%esi),%eax
        movl    %eax,FPU_accum_2
        movl    SIGH(%esi),%eax
        movl    %eax,FPU_accum_3
        xorl    %eax,%eax
        movl    %eax,FPU_accum_1        /* zero the extension */
        movl    %eax,FPU_accum_0        /* zero the extension */
 
        movl    SIGL(%esi),%eax /* Get the current num */
        movl    SIGH(%esi),%edx
 
/*----------------------------------------------------------------------*/
/* Initialization done.
   Do the first 32 bits. */
 
        movb    $0,FPU_ovfl_flag
        cmpl    SIGH(%ebx),%edx /* Test for imminent overflow */
        jb      LLess_than_1
        ja      LGreater_than_1
 
        cmpl    SIGL(%ebx),%eax
        jb      LLess_than_1
 
LGreater_than_1:
/* The dividend is greater or equal, would cause overflow */
        setaeb  FPU_ovfl_flag           /* Keep a record */
 
        subl    SIGL(%ebx),%eax
        sbbl    SIGH(%ebx),%edx /* Prevent the overflow */
        movl    %eax,FPU_accum_2
        movl    %edx,FPU_accum_3
 
LLess_than_1:
/* At this point, we have a dividend < divisor, with a record of
   adjustment in FPU_ovfl_flag */
 
        /* We will divide by a number which is too large */
        movl    SIGH(%ebx),%ecx
        addl    $1,%ecx
        jnc     LFirst_div_not_1
 
        /* here we need to divide by 100000000h,
           i.e., no division at all.. */
        mov     %edx,%eax
        jmp     LFirst_div_done
 
LFirst_div_not_1:
        divl    %ecx            /* Divide the numerator by the augmented
                                   denom ms dw */
 
LFirst_div_done:
        movl    %eax,FPU_result_2       /* Put the result in the answer */
 
        mull    SIGH(%ebx)      /* mul by the ms dw of the denom */
 
        subl    %eax,FPU_accum_2        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_3
 
        movl    FPU_result_2,%eax       /* Get the result back */
        mull    SIGL(%ebx)      /* now mul the ls dw of the denom */
 
        subl    %eax,FPU_accum_1        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_2
        sbbl    $0,FPU_accum_3
        je      LDo_2nd_32_bits         /* Must check for non-zero result here */
 
#ifdef PARANOID
        jb      L_bugged_1
#endif /* PARANOID */
 
        /* need to subtract another once of the denom */
        incl    FPU_result_2    /* Correct the answer */
 
        movl    SIGL(%ebx),%eax
        movl    SIGH(%ebx),%edx
        subl    %eax,FPU_accum_1        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_2
 
#ifdef PARANOID
        sbbl    $0,FPU_accum_3
        jne     L_bugged_1      /* Must check for non-zero result here */
#endif /* PARANOID */
 
/*----------------------------------------------------------------------*/
/* Half of the main problem is done, there is just a reduced numerator
   to handle now.
   Work with the second 32 bits, FPU_accum_0 not used from now on */
LDo_2nd_32_bits:
        movl    FPU_accum_2,%edx        /* get the reduced num */
        movl    FPU_accum_1,%eax
 
        /* need to check for possible subsequent overflow */
        cmpl    SIGH(%ebx),%edx
        jb      LDo_2nd_div
        ja      LPrevent_2nd_overflow
 
        cmpl    SIGL(%ebx),%eax
        jb      LDo_2nd_div
 
LPrevent_2nd_overflow:
/* The numerator is greater or equal, would cause overflow */
        /* prevent overflow */
        subl    SIGL(%ebx),%eax
        sbbl    SIGH(%ebx),%edx
        movl    %edx,FPU_accum_2
        movl    %eax,FPU_accum_1
 
        incl    FPU_result_2    /* Reflect the subtraction in the answer */
 
#ifdef PARANOID
        je      L_bugged_2      /* Can't bump the result to 1.0 */
#endif /* PARANOID */
 
LDo_2nd_div:
        cmpl    $0,%ecx         /* augmented denom msw */
        jnz     LSecond_div_not_1
 
        /* %ecx == 0, we are dividing by 1.0 */
        mov     %edx,%eax
        jmp     LSecond_div_done
 
LSecond_div_not_1:
        divl    %ecx            /* Divide the numerator by the denom ms dw */
 
LSecond_div_done:
        movl    %eax,FPU_result_1       /* Put the result in the answer */
 
        mull    SIGH(%ebx)      /* mul by the ms dw of the denom */
 
        subl    %eax,FPU_accum_1        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_2
 
#ifdef PARANOID
        jc      L_bugged_2
#endif /* PARANOID */
 
        movl    FPU_result_1,%eax       /* Get the result back */
        mull    SIGL(%ebx)      /* now mul the ls dw of the denom */
 
        subl    %eax,FPU_accum_0        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_1        /* Subtract from the num local reg */
        sbbl    $0,FPU_accum_2
 
#ifdef PARANOID
        jc      L_bugged_2
#endif /* PARANOID */
 
        jz      LDo_3rd_32_bits
 
#ifdef PARANOID
        cmpl    $1,FPU_accum_2
        jne     L_bugged_2
#endif /* PARANOID */
 
        /* need to subtract another once of the denom */
        movl    SIGL(%ebx),%eax
        movl    SIGH(%ebx),%edx
        subl    %eax,FPU_accum_0        /* Subtract from the num local reg */
        sbbl    %edx,FPU_accum_1
        sbbl    $0,FPU_accum_2
 
#ifdef PARANOID
        jc      L_bugged_2
        jne     L_bugged_2
#endif /* PARANOID */
 
        addl    $1,FPU_result_1 /* Correct the answer */
        adcl    $0,FPU_result_2
 
#ifdef PARANOID
        jc      L_bugged_2      /* Must check for non-zero result here */
#endif /* PARANOID */
 
/*----------------------------------------------------------------------*/
/* The division is essentially finished here, we just need to perform
   tidying operations.
   Deal with the 3rd 32 bits */
LDo_3rd_32_bits:
        movl    FPU_accum_1,%edx                /* get the reduced num */
        movl    FPU_accum_0,%eax
 
        /* need to check for possible subsequent overflow */
        cmpl    SIGH(%ebx),%edx /* denom */
        jb      LRound_prep
        ja      LPrevent_3rd_overflow
 
        cmpl    SIGL(%ebx),%eax /* denom */
        jb      LRound_prep
 
LPrevent_3rd_overflow:
        /* prevent overflow */
        subl    SIGL(%ebx),%eax
        sbbl    SIGH(%ebx),%edx
        movl    %edx,FPU_accum_1
        movl    %eax,FPU_accum_0
 
        addl    $1,FPU_result_1 /* Reflect the subtraction in the answer */
        adcl    $0,FPU_result_2
        jne     LRound_prep
        jnc     LRound_prep
 
        /* This is a tricky spot, there is an overflow of the answer */
        movb    $255,FPU_ovfl_flag              /* Overflow -> 1.000 */
 
LRound_prep:
/*
 * Prepare for rounding.
 * To test for rounding, we just need to compare 2*accum with the
 * denom.
 */
        movl    FPU_accum_0,%ecx
        movl    FPU_accum_1,%edx
        movl    %ecx,%eax
        orl     %edx,%eax
        jz      LRound_ovfl             /* The accumulator contains zero. */
 
        /* Multiply by 2 */
        clc
        rcll    $1,%ecx
        rcll    $1,%edx
        jc      LRound_large            /* No need to compare, denom smaller */
 
        subl    SIGL(%ebx),%ecx
        sbbl    SIGH(%ebx),%edx
        jnc     LRound_not_small
 
        movl    $0x70000000,%eax        /* Denom was larger */
        jmp     LRound_ovfl
 
LRound_not_small:
        jnz     LRound_large
 
        movl    $0x80000000,%eax        /* Remainder was exactly 1/2 denom */
        jmp     LRound_ovfl
 
LRound_large:
        movl    $0xff000000,%eax        /* Denom was smaller */
 
LRound_ovfl:
/* We are now ready to deal with rounding, but first we must get
   the bits properly aligned */
        testb   $255,FPU_ovfl_flag      /* was the num > denom ? */
        je      LRound_precision
 
        incw    EXP(%edi)
 
        /* shift the mantissa right one bit */
        stc                     /* Will set the ms bit */
        rcrl    FPU_result_2
        rcrl    FPU_result_1
        rcrl    %eax
 
/* Round the result as required */
LRound_precision:
        decw    EXP(%edi)       /* binary point between 1st & 2nd bits */
 
        movl    %eax,%edx
        movl    FPU_result_1,%ebx
        movl    FPU_result_2,%eax
        jmp     fpu_reg_round
 
 
#ifdef PARANOID
/* The logic is wrong if we got here */
L_bugged:
        pushl   EX_INTERNAL|0x202
        call    EXCEPTION
        pop     %ebx
        jmp     L_exit
 
L_bugged_1:
        pushl   EX_INTERNAL|0x203
        call    EXCEPTION
        pop     %ebx
        jmp     L_exit
 
L_bugged_2:
        pushl   EX_INTERNAL|0x204
        call    EXCEPTION
        pop     %ebx
        jmp     L_exit
 
L_exit:
        movl    $-1,%eax
        popl    %ebx
        popl    %edi
        popl    %esi
 
        leave
        ret
#endif /* PARANOID */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [i386/] [math-emu/] [reg_u_div.S] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`.file "reg_u_div.S"`
2			`/*---------------------------------------------------------------------------+`
3			`\| reg_u_div.S \|`
4			`\| \|`
5			`\| Divide one FPU_REG by another and put the result in a destination FPU_REG.\|`
6			`\| \|`
7			`\| Copyright (C) 1992,1993,1995,1997 \|`
8			`\| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia \|`
9			`\| E-mail billm@suburbia.net \|`
10			`\| \|`
11			`\| \|`
12			`+---------------------------------------------------------------------------*/`
13
14			`/*---------------------------------------------------------------------------+`
15			`\| Call from C as: \|`
16			`\| int FPU_u_div(FPU_REG a, FPU_REG b, FPU_REG *dest, \|`
17			`\| unsigned int control_word, char *sign) \|`
18			`\| \|`
19			`\| Does not compute the destination exponent, but does adjust it. \|`
20			`\| \|`
21			`\| Return value is the tag of the answer, or-ed with FPU_Exception if \|`
22			`\| one was raised, or -1 on internal error. \|`
23			`+---------------------------------------------------------------------------*/`
24
25			`#include "exception.h"`
26			`#include "fpu_emu.h"`
27			`#include "control_w.h"`
28
29
30			`/* #define dSIGL(x) (x) */`
31			`/* #define dSIGH(x) 4(x) */`
32
33
34			`#ifndef NON_REENTRANT_FPU`
35			`/*`
36			`Local storage on the stack:`
37			`Result: FPU_accum_3:FPU_accum_2:FPU_accum_1:FPU_accum_0`
38			`Overflow flag: ovfl_flag`
39			`*/`
40			`#define FPU_accum_3 -4(%ebp)`
41			`#define FPU_accum_2 -8(%ebp)`
42			`#define FPU_accum_1 -12(%ebp)`
43			`#define FPU_accum_0 -16(%ebp)`
44			`#define FPU_result_1 -20(%ebp)`
45			`#define FPU_result_2 -24(%ebp)`
46			`#define FPU_ovfl_flag -28(%ebp)`
47
48			`#else`
49			`.data`
50			`/*`
51			`Local storage in a static area:`
52			`Result: FPU_accum_3:FPU_accum_2:FPU_accum_1:FPU_accum_0`
53			`Overflow flag: ovfl_flag`
54			`*/`
55			`.align 4,0`
56			`FPU_accum_3:`
57			`.long 0`
58			`FPU_accum_2:`
59			`.long 0`
60			`FPU_accum_1:`
61			`.long 0`
62			`FPU_accum_0:`
63			`.long 0`
64			`FPU_result_1:`
65			`.long 0`
66			`FPU_result_2:`
67			`.long 0`
68			`FPU_ovfl_flag:`
69			`.byte 0`
70			`#endif /* NON_REENTRANT_FPU */`
71
72			`#define REGA PARAM1`
73			`#define REGB PARAM2`
74			`#define DEST PARAM3`
75
76			`.text`
77			`ENTRY(FPU_u_div)`
78			`pushl %ebp`
79			`movl %esp,%ebp`
80			`#ifndef NON_REENTRANT_FPU`
81			`subl $28,%esp`
82			`#endif /* NON_REENTRANT_FPU */`
83
84			`pushl %esi`
85			`pushl %edi`
86			`pushl %ebx`
87
88			`movl REGA,%esi`
89			`movl REGB,%ebx`
90			`movl DEST,%edi`
91
92			`movswl EXP(%esi),%edx`
93			`movswl EXP(%ebx),%eax`
94			`subl %eax,%edx`
95			`addl EXP_BIAS,%edx`
96
97			`/* A denormal and a large number can cause an exponent underflow */`
98			`cmpl EXP_WAY_UNDER,%edx`
99			`jg xExp_not_underflow`
100
101			`/* Set to a really low value allow correct handling */`
102			`movl EXP_WAY_UNDER,%edx`
103
104			`xExp_not_underflow:`
105
106			`movw %dx,EXP(%edi)`
107
108			`#ifdef PARANOID`
109			`/* testl $0x80000000, SIGH(%esi) // Dividend */`
110			`/* je L_bugged */`
111			`testl $0x80000000, SIGH(%ebx) /* Divisor */`
112			`je L_bugged`
113			`#endif /* PARANOID */`
114
115			`/* Check if the divisor can be treated as having just 32 bits */`
116			`cmpl $0,SIGL(%ebx)`
117			`jnz L_Full_Division /* Can't do a quick divide */`
118
119			`/* We should be able to zip through the division here */`
120			`movl SIGH(%ebx),%ecx /* The divisor */`
121			`movl SIGH(%esi),%edx /* Dividend */`
122			`movl SIGL(%esi),%eax /* Dividend */`
123
124			`cmpl %ecx,%edx`
125			`setaeb FPU_ovfl_flag /* Keep a record */`
126			`jb L_no_adjust`
127
128			`subl %ecx,%edx /* Prevent the overflow */`
129
130			`L_no_adjust:`
131			`/* Divide the 64 bit number by the 32 bit denominator */`
132			`divl %ecx`
133			`movl %eax,FPU_result_2`
134
135			`/* Work on the remainder of the first division */`
136			`xorl %eax,%eax`
137			`divl %ecx`
138			`movl %eax,FPU_result_1`
139
140			`/* Work on the remainder of the 64 bit division */`
141			`xorl %eax,%eax`
142			`divl %ecx`
143
144			`testb $255,FPU_ovfl_flag /* was the num > denom ? */`
145			`je L_no_overflow`
146
147			`/* Do the shifting here */`
148			`/* increase the exponent */`
149			`incw EXP(%edi)`
150
151			`/* shift the mantissa right one bit */`
152			`stc /* To set the ms bit */`
153			`rcrl FPU_result_2`
154			`rcrl FPU_result_1`
155			`rcrl %eax`
156
157			`L_no_overflow:`
158			`jmp LRound_precision /* Do the rounding as required */`
159
160
161			`/*---------------------------------------------------------------------------+`
162			`\| Divide: Return arg1/arg2 to arg3. \|`
163			`\| \|`
164			`\| This routine does not use the exponents of arg1 and arg2, but does \|`
165			`\| adjust the exponent of arg3. \|`
166			`\| \|`
167			`\| The maximum returned value is (ignoring exponents) \|`
168			`\| .ffffffff ffffffff \|`
169			`\| ------------------ = 1.ffffffff fffffffe \|`
170			`\| .80000000 00000000 \|`
171			`\| and the minimum is \|`
172			`\| .80000000 00000000 \|`
173			`\| ------------------ = .80000000 00000001 (rounded) \|`
174			`\| .ffffffff ffffffff \|`
175			`\| \|`
176			`+---------------------------------------------------------------------------*/`
177
178
179			`L_Full_Division:`
180			`/* Save extended dividend in local register */`
181			`movl SIGL(%esi),%eax`
182			`movl %eax,FPU_accum_2`
183			`movl SIGH(%esi),%eax`
184			`movl %eax,FPU_accum_3`
185			`xorl %eax,%eax`
186			`movl %eax,FPU_accum_1 /* zero the extension */`
187			`movl %eax,FPU_accum_0 /* zero the extension */`
188
189			`movl SIGL(%esi),%eax /* Get the current num */`
190			`movl SIGH(%esi),%edx`
191
192			`/----------------------------------------------------------------------/`
193			`/* Initialization done.`
194			`Do the first 32 bits. */`
195
196			`movb $0,FPU_ovfl_flag`
197			`cmpl SIGH(%ebx),%edx /* Test for imminent overflow */`
198			`jb LLess_than_1`
199			`ja LGreater_than_1`
200
201			`cmpl SIGL(%ebx),%eax`
202			`jb LLess_than_1`
203
204			`LGreater_than_1:`
205			`/* The dividend is greater or equal, would cause overflow */`
206			`setaeb FPU_ovfl_flag /* Keep a record */`
207
208			`subl SIGL(%ebx),%eax`
209			`sbbl SIGH(%ebx),%edx /* Prevent the overflow */`
210			`movl %eax,FPU_accum_2`
211			`movl %edx,FPU_accum_3`
212
213			`LLess_than_1:`
214			`/* At this point, we have a dividend < divisor, with a record of`
215			`adjustment in FPU_ovfl_flag */`
216
217			`/* We will divide by a number which is too large */`
218			`movl SIGH(%ebx),%ecx`
219			`addl $1,%ecx`
220			`jnc LFirst_div_not_1`
221
222			`/* here we need to divide by 100000000h,`
223			`i.e., no division at all.. */`
224			`mov %edx,%eax`
225			`jmp LFirst_div_done`
226
227			`LFirst_div_not_1:`
228			`divl %ecx /* Divide the numerator by the augmented`
229			`denom ms dw */`
230
231			`LFirst_div_done:`
232			`movl %eax,FPU_result_2 /* Put the result in the answer */`
233
234			`mull SIGH(%ebx) /* mul by the ms dw of the denom */`
235
236			`subl %eax,FPU_accum_2 /* Subtract from the num local reg */`
237			`sbbl %edx,FPU_accum_3`
238
239			`movl FPU_result_2,%eax /* Get the result back */`
240			`mull SIGL(%ebx) /* now mul the ls dw of the denom */`
241
242			`subl %eax,FPU_accum_1 /* Subtract from the num local reg */`
243			`sbbl %edx,FPU_accum_2`
244			`sbbl $0,FPU_accum_3`
245			`je LDo_2nd_32_bits /* Must check for non-zero result here */`
246
247			`#ifdef PARANOID`
248			`jb L_bugged_1`
249			`#endif /* PARANOID */`
250
251			`/* need to subtract another once of the denom */`
252			`incl FPU_result_2 /* Correct the answer */`
253
254			`movl SIGL(%ebx),%eax`
255			`movl SIGH(%ebx),%edx`
256			`subl %eax,FPU_accum_1 /* Subtract from the num local reg */`
257			`sbbl %edx,FPU_accum_2`
258
259			`#ifdef PARANOID`
260			`sbbl $0,FPU_accum_3`
261			`jne L_bugged_1 /* Must check for non-zero result here */`
262			`#endif /* PARANOID */`
263
264			`/----------------------------------------------------------------------/`
265			`/* Half of the main problem is done, there is just a reduced numerator`
266			`to handle now.`
267			`Work with the second 32 bits, FPU_accum_0 not used from now on */`
268			`LDo_2nd_32_bits:`
269			`movl FPU_accum_2,%edx /* get the reduced num */`
270			`movl FPU_accum_1,%eax`
271
272			`/* need to check for possible subsequent overflow */`
273			`cmpl SIGH(%ebx),%edx`
274			`jb LDo_2nd_div`
275			`ja LPrevent_2nd_overflow`
276
277			`cmpl SIGL(%ebx),%eax`
278			`jb LDo_2nd_div`
279
280			`LPrevent_2nd_overflow:`
281			`/* The numerator is greater or equal, would cause overflow */`
282			`/* prevent overflow */`
283			`subl SIGL(%ebx),%eax`
284			`sbbl SIGH(%ebx),%edx`
285			`movl %edx,FPU_accum_2`
286			`movl %eax,FPU_accum_1`
287
288			`incl FPU_result_2 /* Reflect the subtraction in the answer */`
289
290			`#ifdef PARANOID`
291			`je L_bugged_2 /* Can't bump the result to 1.0 */`
292			`#endif /* PARANOID */`
293
294			`LDo_2nd_div:`
295			`cmpl $0,%ecx /* augmented denom msw */`
296			`jnz LSecond_div_not_1`
297
298			`/* %ecx == 0, we are dividing by 1.0 */`
299			`mov %edx,%eax`
300			`jmp LSecond_div_done`
301
302			`LSecond_div_not_1:`
303			`divl %ecx /* Divide the numerator by the denom ms dw */`
304
305			`LSecond_div_done:`
306			`movl %eax,FPU_result_1 /* Put the result in the answer */`
307
308			`mull SIGH(%ebx) /* mul by the ms dw of the denom */`
309
310			`subl %eax,FPU_accum_1 /* Subtract from the num local reg */`
311			`sbbl %edx,FPU_accum_2`
312
313			`#ifdef PARANOID`
314			`jc L_bugged_2`
315			`#endif /* PARANOID */`
316
317			`movl FPU_result_1,%eax /* Get the result back */`
318			`mull SIGL(%ebx) /* now mul the ls dw of the denom */`
319
320			`subl %eax,FPU_accum_0 /* Subtract from the num local reg */`
321			`sbbl %edx,FPU_accum_1 /* Subtract from the num local reg */`
322			`sbbl $0,FPU_accum_2`
323
324			`#ifdef PARANOID`
325			`jc L_bugged_2`
326			`#endif /* PARANOID */`
327
328			`jz LDo_3rd_32_bits`
329
330			`#ifdef PARANOID`
331			`cmpl $1,FPU_accum_2`
332			`jne L_bugged_2`
333			`#endif /* PARANOID */`
334
335			`/* need to subtract another once of the denom */`
336			`movl SIGL(%ebx),%eax`
337			`movl SIGH(%ebx),%edx`
338			`subl %eax,FPU_accum_0 /* Subtract from the num local reg */`
339			`sbbl %edx,FPU_accum_1`
340			`sbbl $0,FPU_accum_2`
341
342			`#ifdef PARANOID`
343			`jc L_bugged_2`
344			`jne L_bugged_2`
345			`#endif /* PARANOID */`
346
347			`addl $1,FPU_result_1 /* Correct the answer */`
348			`adcl $0,FPU_result_2`
349
350			`#ifdef PARANOID`
351			`jc L_bugged_2 /* Must check for non-zero result here */`
352			`#endif /* PARANOID */`
353
354			`/----------------------------------------------------------------------/`
355			`/* The division is essentially finished here, we just need to perform`
356			`tidying operations.`
357			`Deal with the 3rd 32 bits */`
358			`LDo_3rd_32_bits:`
359			`movl FPU_accum_1,%edx /* get the reduced num */`
360			`movl FPU_accum_0,%eax`
361
362			`/* need to check for possible subsequent overflow */`
363			`cmpl SIGH(%ebx),%edx /* denom */`
364			`jb LRound_prep`
365			`ja LPrevent_3rd_overflow`
366
367			`cmpl SIGL(%ebx),%eax /* denom */`
368			`jb LRound_prep`
369
370			`LPrevent_3rd_overflow:`
371			`/* prevent overflow */`
372			`subl SIGL(%ebx),%eax`
373			`sbbl SIGH(%ebx),%edx`
374			`movl %edx,FPU_accum_1`
375			`movl %eax,FPU_accum_0`
376
377			`addl $1,FPU_result_1 /* Reflect the subtraction in the answer */`
378			`adcl $0,FPU_result_2`
379			`jne LRound_prep`
380			`jnc LRound_prep`
381
382			`/* This is a tricky spot, there is an overflow of the answer */`
383			`movb $255,FPU_ovfl_flag /* Overflow -> 1.000 */`
384
385			`LRound_prep:`
386			`/*`
387			`* Prepare for rounding.`
388			`* To test for rounding, we just need to compare 2*accum with the`
389			`* denom.`
390			`*/`
391			`movl FPU_accum_0,%ecx`
392			`movl FPU_accum_1,%edx`
393			`movl %ecx,%eax`
394			`orl %edx,%eax`
395			`jz LRound_ovfl /* The accumulator contains zero. */`
396
397			`/* Multiply by 2 */`
398			`clc`
399			`rcll $1,%ecx`
400			`rcll $1,%edx`
401			`jc LRound_large /* No need to compare, denom smaller */`
402
403			`subl SIGL(%ebx),%ecx`
404			`sbbl SIGH(%ebx),%edx`
405			`jnc LRound_not_small`
406
407			`movl $0x70000000,%eax /* Denom was larger */`
408			`jmp LRound_ovfl`
409
410			`LRound_not_small:`
411			`jnz LRound_large`
412
413			`movl $0x80000000,%eax /* Remainder was exactly 1/2 denom */`
414			`jmp LRound_ovfl`
415
416			`LRound_large:`
417			`movl $0xff000000,%eax /* Denom was smaller */`
418
419			`LRound_ovfl:`
420			`/* We are now ready to deal with rounding, but first we must get`
421			`the bits properly aligned */`
422			`testb $255,FPU_ovfl_flag /* was the num > denom ? */`
423			`je LRound_precision`
424
425			`incw EXP(%edi)`
426
427			`/* shift the mantissa right one bit */`
428			`stc /* Will set the ms bit */`
429			`rcrl FPU_result_2`
430			`rcrl FPU_result_1`
431			`rcrl %eax`
432
433			`/* Round the result as required */`
434			`LRound_precision:`
435			`decw EXP(%edi) /* binary point between 1st & 2nd bits */`
436
437			`movl %eax,%edx`
438			`movl FPU_result_1,%ebx`
439			`movl FPU_result_2,%eax`
440			`jmp fpu_reg_round`
441
442
443			`#ifdef PARANOID`
444			`/* The logic is wrong if we got here */`
445			`L_bugged:`
446			`pushl EX_INTERNAL\|0x202`
447			`call EXCEPTION`
448			`pop %ebx`
449			`jmp L_exit`
450
451			`L_bugged_1:`
452			`pushl EX_INTERNAL\|0x203`
453			`call EXCEPTION`
454			`pop %ebx`
455			`jmp L_exit`
456
457			`L_bugged_2:`
458			`pushl EX_INTERNAL\|0x204`
459			`call EXCEPTION`
460			`pop %ebx`
461			`jmp L_exit`
462
463			`L_exit:`
464			`movl $-1,%eax`
465			`popl %ebx`
466			`popl %edi`
467			`popl %esi`
468
469			`leave`
470			`ret`
471			`#endif /* PARANOID */`