| /* Copyright (C) 1996-2014 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Richard Henderson <rth@tamu.edu>. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "div_libc.h" |
| |
| #undef FRAME |
| #ifdef __alpha_fix__ |
| #define FRAME 0 |
| #else |
| #define FRAME 16 |
| #endif |
| |
| #undef X |
| #undef Y |
| #define X $17 |
| #define Y $18 |
| |
| .set noat |
| |
| .align 4 |
| .globl ldiv |
| .ent ldiv |
| ldiv: |
| .frame sp, FRAME, ra |
| #if FRAME > 0 |
| lda sp, -FRAME(sp) |
| #endif |
| #ifdef PROF |
| .set macro |
| ldgp gp, 0(pv) |
| lda AT, _mcount |
| jsr AT, (AT), _mcount |
| .set nomacro |
| .prologue 1 |
| #else |
| .prologue 0 |
| #endif |
| |
| beq Y, $divbyzero |
| excb |
| mf_fpcr $f10 |
| |
| _ITOFT2 X, $f0, 0, Y, $f1, 8 |
| |
| .align 4 |
| cvtqt $f0, $f0 |
| cvtqt $f1, $f1 |
| divt/c $f0, $f1, $f0 |
| unop |
| |
| /* Check to see if X fit in the double as an exact value. */ |
| sll X, (64-53), AT |
| sra AT, (64-53), AT |
| cmpeq X, AT, AT |
| beq AT, $x_big |
| |
| /* If we get here, we're expecting exact results from the division. |
| Do nothing else besides convert and clean up. */ |
| cvttq/c $f0, $f0 |
| excb |
| mt_fpcr $f10 |
| _FTOIT $f0, $0, 0 |
| |
| $egress: |
| mulq $0, Y, $1 |
| subq X, $1, $1 |
| |
| stq $0, 0($16) |
| stq $1, 8($16) |
| mov $16, $0 |
| |
| #if FRAME > 0 |
| lda sp, FRAME(sp) |
| #endif |
| ret |
| |
| .align 4 |
| $x_big: |
| /* If we get here, X is large enough that we don't expect exact |
| results, and neither X nor Y got mis-translated for the fp |
| division. Our task is to take the fp result, figure out how |
| far it's off from the correct result and compute a fixup. */ |
| |
| #define Q v0 /* quotient */ |
| #define R t0 /* remainder */ |
| #define SY t1 /* scaled Y */ |
| #define S t2 /* scalar */ |
| #define QY t3 /* Q*Y */ |
| |
| /* The fixup code below can only handle unsigned values. */ |
| or X, Y, AT |
| mov $31, t5 |
| blt AT, $fix_sign_in |
| $fix_sign_in_ret1: |
| cvttq/c $f0, $f0 |
| |
| _FTOIT $f0, Q, 8 |
| $fix_sign_in_ret2: |
| mulq Q, Y, QY |
| excb |
| mt_fpcr $f10 |
| |
| .align 4 |
| subq QY, X, R |
| mov Y, SY |
| mov 1, S |
| bgt R, $q_high |
| |
| $q_high_ret: |
| subq X, QY, R |
| mov Y, SY |
| mov 1, S |
| bgt R, $q_low |
| |
| $q_low_ret: |
| negq Q, t4 |
| cmovlbs t5, t4, Q |
| br $egress |
| |
| .align 4 |
| /* The quotient that we computed was too large. We need to reduce |
| it by S such that Y*S >= R. Obviously the closer we get to the |
| correct value the better, but overshooting high is ok, as we'll |
| fix that up later. */ |
| 0: |
| addq SY, SY, SY |
| addq S, S, S |
| $q_high: |
| cmpult SY, R, AT |
| bne AT, 0b |
| |
| subq Q, S, Q |
| unop |
| subq QY, SY, QY |
| br $q_high_ret |
| |
| .align 4 |
| /* The quotient that we computed was too small. Divide Y by the |
| current remainder (R) and add that to the existing quotient (Q). |
| The expectation, of course, is that R is much smaller than X. */ |
| /* Begin with a shift-up loop. Compute S such that Y*S >= R. We |
| already have a copy of Y in SY and the value 1 in S. */ |
| 0: |
| addq SY, SY, SY |
| addq S, S, S |
| $q_low: |
| cmpult SY, R, AT |
| bne AT, 0b |
| |
| /* Shift-down and subtract loop. Each iteration compares our scaled |
| Y (SY) with the remainder (R); if SY <= R then X is divisible by |
| Y's scalar (S) so add it to the quotient (Q). */ |
| 2: addq Q, S, t3 |
| srl S, 1, S |
| cmpule SY, R, AT |
| subq R, SY, t4 |
| |
| cmovne AT, t3, Q |
| cmovne AT, t4, R |
| srl SY, 1, SY |
| bne S, 2b |
| |
| br $q_low_ret |
| |
| .align 4 |
| $fix_sign_in: |
| /* If we got here, then X|Y is negative. Need to adjust everything |
| such that we're doing unsigned division in the fixup loop. */ |
| /* T5 is true if result should be negative. */ |
| xor X, Y, AT |
| cmplt AT, 0, t5 |
| cmplt X, 0, AT |
| negq X, t0 |
| |
| cmovne AT, t0, X |
| cmplt Y, 0, AT |
| negq Y, t0 |
| |
| cmovne AT, t0, Y |
| blbc t5, $fix_sign_in_ret1 |
| |
| cvttq/c $f0, $f0 |
| _FTOIT $f0, Q, 8 |
| .align 3 |
| negq Q, Q |
| br $fix_sign_in_ret2 |
| |
| $divbyzero: |
| mov a0, v0 |
| lda a0, GEN_INTDIV |
| call_pal PAL_gentrap |
| stq zero, 0(v0) |
| stq zero, 8(v0) |
| |
| #if FRAME > 0 |
| lda sp, FRAME(sp) |
| #endif |
| ret |
| |
| .end ldiv |
| |
| weak_alias (ldiv, lldiv) |
| weak_alias (ldiv, imaxdiv) |
