chromium / chromiumos / third_party / glibc-ports / refs/heads/factory-1987.B / . / sysdeps / alpha / ldiv.S

/* Copyright (C) 1996, 1997, 2001, 2004 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, write to the Free | |

Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |

02111-1307 USA. */ | |

#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) |