/* Copyright (C) 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include "div_libc.h"
/* 64-bit unsigned long remainder. These are not normal C functions. Argument
registers are t10 and t11, the result goes in t12. Only t12 and AT may be
clobbered.
Theory of operation here is that we can use the FPU divider for virtually
all operands that we see: all dividend values between -2**53 and 2**53-1
can be computed directly. Note that divisor values need not be checked
against that range because the rounded fp value will be close enough such
that the quotient is < 1, which will properly be truncated to zero when we
convert back to integer.
When the dividend is outside the range for which we can compute exact
results, we use the fp quotent as an estimate from which we begin refining
an exact integral value. This reduces the number of iterations in the
shift-and-subtract loop significantly.
The FPCR save/restore is due to the fact that the EV6 _will_ set FPCR_INE
for cvttq/c even without /sui being set. It will not, however, properly
raise the exception, so we don't have to worry about FPCR_INED being clear
and so dying by SIGFPE. */
.text
.align 4
.globl __remqu
.type __remqu, @funcnoplt
.usepv __remqu, no
cfi_startproc
cfi_return_column (RA)
__remqu:
lda sp, -FRAME(sp)
cfi_def_cfa_offset (FRAME)
CALL_MCOUNT
/* Get the fp divide insn issued as quickly as possible. After
that's done, we have at least 22 cycles until its results are
ready -- all the time in the world to figure out how we're
going to use the results. */
subq Y, 1, AT
stt $f0, 0(sp)
and Y, AT, AT
stt $f1, 8(sp)
excb
stt $f3, 48(sp)
beq AT, $powerof2
cfi_rel_offset ($f0, 0)
cfi_rel_offset ($f1, 8)
cfi_rel_offset ($f3, 48)
_ITOFT2 X, $f0, 16, Y, $f1, 24
mf_fpcr $f3
cvtqt $f0, $f0
cvtqt $f1, $f1
blt X, $x_is_neg
divt/c $f0, $f1, $f0
/* Check to see if Y was mis-converted as signed value. */
ldt $f1, 8(sp)
blt Y, $y_is_neg
/* Check to see if X fit in the double as an exact value. */
srl X, 53, AT
bne AT, $x_big
/* If we get here, we're expecting exact results from the division.
Do nothing else besides convert, compute remainder, clean up. */
cvttq/c $f0, $f0
excb
mt_fpcr $f3
_FTOIT $f0, AT, 16
mulq AT, Y, AT
ldt $f0, 0(sp)
ldt $f3, 48(sp)
lda sp, FRAME(sp)
cfi_remember_state
cfi_restore ($f0)
cfi_restore ($f1)
cfi_restore ($f3)
cfi_def_cfa_offset (0)
.align 4
subq X, AT, RV
ret $31, (RA), 1
.align 4
cfi_restore_state
$x_is_neg:
/* If we get here, X is so big that bit 63 is set, which made the
conversion come out negative. Fix it up lest we not even get
a good estimate. */
ldah AT, 0x5f80 /* 2**64 as float. */
stt $f2, 24(sp)
cfi_rel_offset ($f2, 24)
_ITOFS AT, $f2, 16
addt $f0, $f2, $f0
divt/c $f0, $f1, $f0
/* Ok, we've now the divide issued. Continue with other checks. */
.align 4
ldt $f1, 8(sp)
unop
ldt $f2, 24(sp)
blt Y, $y_is_neg
cfi_restore ($f1)
cfi_restore ($f2)
cfi_remember_state /* for y_is_neg */
.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. */
stq t0, 16(sp)
stq t1, 24(sp)
stq t2, 32(sp)
stq t3, 40(sp)
cfi_rel_offset (t0, 16)
cfi_rel_offset (t1, 24)
cfi_rel_offset (t2, 32)
cfi_rel_offset (t3, 40)
#define Q t0 /* quotient */
#define R RV /* remainder */
#define SY t1 /* scaled Y */
#define S t2 /* scalar */
#define QY t3 /* Q*Y */
cvttq/c $f0, $f0
_FTOIT $f0, Q, 8
mulq Q, Y, QY
.align 4
stq t4, 8(sp)
excb
ldt $f0, 0(sp)
mt_fpcr $f3
cfi_rel_offset (t4, 8)
cfi_restore ($f0)
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:
ldq t4, 8(sp)
ldq t0, 16(sp)
ldq t1, 24(sp)
ldq t2, 32(sp)
ldq t3, 40(sp)
ldt $f3, 48(sp)
lda sp, FRAME(sp)
cfi_remember_state
cfi_restore (t0)
cfi_restore (t1)
cfi_restore (t2)
cfi_restore (t3)
cfi_restore (t4)
cfi_restore ($f3)
cfi_def_cfa_offset (0)
ret $31, (RA), 1
.align 4
cfi_restore_state
/* 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
cfi_restore_state
$y_is_neg:
/* If we get here, Y is so big that bit 63 is set. The results
from the divide will be completely wrong. Fortunately, the
quotient must be either 0 or 1, so the remainder must be X
or X-Y, so just compute it directly. */
cmpult Y, X, AT
subq X, Y, RV
ldt $f0, 0(sp)
cmoveq AT, X, RV
lda sp, FRAME(sp)
cfi_restore ($f0)
cfi_def_cfa_offset (0)
ret $31, (RA), 1
.align 4
cfi_def_cfa_offset (FRAME)
$powerof2:
subq Y, 1, AT
beq Y, DIVBYZERO
and X, AT, RV
lda sp, FRAME(sp)
cfi_def_cfa_offset (0)
ret $31, (RA), 1
cfi_endproc
.size __remqu, .-__remqu
DO_DIVBYZERO