LXR linux/arch/x86/math-emu/reg_u

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