mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-26 20:51:11 +00:00
219 lines
4.3 KiB
ArmAsm
219 lines
4.3 KiB
ArmAsm
/* 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)
|