1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
/* Copyright (C) 1996-2021 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, see
<https://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)
|
