sysdeps/alpha/ldiv.S

   1 /* Copyright (C) 1996, 1997, 2001, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Richard Henderson <rth@tamu.edu>.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include "div_libc.h"
  21
  22 #undef FRAME
  23 #ifdef __alpha_fix__
  24 #define FRAME 0
  25 #else
  26 #define FRAME 16
  27 #endif
  28
  29 #undef X
  30 #undef Y
  31 #define X $17
  32 #define Y $18
  33
  34         .set noat
  35
  36         .align 4
  37         .globl ldiv
  38         .ent ldiv
  39 ldiv:
  40         .frame sp, FRAME, ra
  41 #if FRAME > 0
  42         lda     sp, -FRAME(sp)
  43 #endif
  44 #ifdef PROF
  45         .set    macro
  46         ldgp    gp, 0(pv)
  47         lda     AT, _mcount
  48         jsr     AT, (AT), _mcount
  49         .set    nomacro
  50         .prologue 1
  51 #else
  52         .prologue 0
  53 #endif
  54
  55         beq     Y, $divbyzero
  56         excb
  57         mf_fpcr $f10
  58
  59         _ITOFT2 X, $f0, 0, Y, $f1, 8
  60
  61         .align  4
  62         cvtqt   $f0, $f0
  63         cvtqt   $f1, $f1
  64         divt/c  $f0, $f1, $f0
  65         unop
  66
  67         /* Check to see if X fit in the double as an exact value.  */
  68         sll     X, (64-53), AT
  69         sra     AT, (64-53), AT
  70         cmpeq   X, AT, AT
  71         beq     AT, $x_big
  72
  73         /* If we get here, we're expecting exact results from the division.
  74            Do nothing else besides convert and clean up.  */
  75         cvttq/c $f0, $f0
  76         excb
  77         mt_fpcr $f10
  78         _FTOIT  $f0, $0, 0
  79
  80 $egress:
  81         mulq    $0, Y, $1
  82         subq    X, $1, $1
  83
  84         stq     $0, 0($16)
  85         stq     $1, 8($16)
  86         mov     $16, $0
  87
  88 #if FRAME > 0
  89         lda     sp, FRAME(sp)
  90 #endif
  91         ret
  92
  93         .align  4
  94 $x_big:
  95         /* If we get here, X is large enough that we don't expect exact
  96            results, and neither X nor Y got mis-translated for the fp
  97            division.  Our task is to take the fp result, figure out how
  98            far it's off from the correct result and compute a fixup.  */
  99
 100 #define Q       v0              /* quotient */
 101 #define R       t0              /* remainder */
 102 #define SY      t1              /* scaled Y */
 103 #define S       t2              /* scalar */
 104 #define QY      t3              /* Q*Y */
 105
 106         /* The fixup code below can only handle unsigned values.  */
 107         or      X, Y, AT
 108         mov     $31, t5
 109         blt     AT, $fix_sign_in
 110 $fix_sign_in_ret1:
 111         cvttq/c $f0, $f0
 112
 113         _FTOIT  $f0, Q, 8
 114 $fix_sign_in_ret2:
 115         mulq    Q, Y, QY
 116         excb
 117         mt_fpcr $f10
 118
 119         .align  4
 120         subq    QY, X, R
 121         mov     Y, SY
 122         mov     1, S
 123         bgt     R, $q_high
 124
 125 $q_high_ret:
 126         subq    X, QY, R
 127         mov     Y, SY
 128         mov     1, S
 129         bgt     R, $q_low
 130
 131 $q_low_ret:
 132         negq    Q, t4
 133         cmovlbs t5, t4, Q
 134         br      $egress
 135
 136         .align  4
 137         /* The quotient that we computed was too large.  We need to reduce
 138            it by S such that Y*S >= R.  Obviously the closer we get to the
 139            correct value the better, but overshooting high is ok, as we'll
 140            fix that up later.  */
 141 0:
 142         addq    SY, SY, SY
 143         addq    S, S, S
 144 $q_high:
 145         cmpult  SY, R, AT
 146         bne     AT, 0b
 147
 148         subq    Q, S, Q
 149         unop
 150         subq    QY, SY, QY
 151         br      $q_high_ret
 152
 153         .align  4
 154         /* The quotient that we computed was too small.  Divide Y by the
 155            current remainder (R) and add that to the existing quotient (Q).
 156            The expectation, of course, is that R is much smaller than X.  */
 157         /* Begin with a shift-up loop.  Compute S such that Y*S >= R.  We
 158            already have a copy of Y in SY and the value 1 in S.  */
 159 0:
 160         addq    SY, SY, SY
 161         addq    S, S, S
 162 $q_low:
 163         cmpult  SY, R, AT
 164         bne     AT, 0b
 165
 166         /* Shift-down and subtract loop.  Each iteration compares our scaled
 167            Y (SY) with the remainder (R); if SY <= R then X is divisible by
 168            Y's scalar (S) so add it to the quotient (Q).  */
 169 2:      addq    Q, S, t3
 170         srl     S, 1, S
 171         cmpule  SY, R, AT
 172         subq    R, SY, t4
 173
 174         cmovne  AT, t3, Q
 175         cmovne  AT, t4, R
 176         srl     SY, 1, SY
 177         bne     S, 2b
 178
 179         br      $q_low_ret
 180
 181         .align  4
 182 $fix_sign_in:
 183         /* If we got here, then X|Y is negative.  Need to adjust everything
 184            such that we're doing unsigned division in the fixup loop.  */
 185         /* T5 is true if result should be negative.  */
 186         xor     X, Y, AT
 187         cmplt   AT, 0, t5
 188         cmplt   X, 0, AT
 189         negq    X, t0
 190
 191         cmovne  AT, t0, X
 192         cmplt   Y, 0, AT
 193         negq    Y, t0
 194
 195         cmovne  AT, t0, Y
 196         blbc    t5, $fix_sign_in_ret1
 197
 198         cvttq/c $f0, $f0
 199         _FTOIT  $f0, Q, 8
 200         .align  3
 201         negq    Q, Q
 202         br      $fix_sign_in_ret2
 203
 204 $divbyzero:
 205         mov     a0, v0
 206         lda     a0, GEN_INTDIV
 207         call_pal PAL_gentrap
 208         stq     zero, 0(v0)
 209         stq     zero, 8(v0)
 210
 211 #if FRAME > 0
 212         lda     sp, FRAME(sp)
 213 #endif
 214         ret
 215
 216         .end    ldiv
 217
 218 weak_alias (ldiv, lldiv)