Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Copyright (C) 2004-2019 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library. If not, see
16 <http://www.gnu.org/licenses/>. */
17
18#include "div_libc.h"
19
20
21/* 64-bit unsigned long remainder. These are not normal C functions. Argument
22 registers are t10 and t11, the result goes in t12. Only t12 and AT may be
23 clobbered.
24
25 Theory of operation here is that we can use the FPU divider for virtually
26 all operands that we see: all dividend values between -2**53 and 2**53-1
27 can be computed directly. Note that divisor values need not be checked
28 against that range because the rounded fp value will be close enough such
29 that the quotient is < 1, which will properly be truncated to zero when we
30 convert back to integer.
31
32 When the dividend is outside the range for which we can compute exact
33 results, we use the fp quotent as an estimate from which we begin refining
34 an exact integral value. This reduces the number of iterations in the
35 shift-and-subtract loop significantly.
36
37 The FPCR save/restore is due to the fact that the EV6 _will_ set FPCR_INE
38 for cvttq/c even without /sui being set. It will not, however, properly
39 raise the exception, so we don't have to worry about FPCR_INED being clear
40 and so dying by SIGFPE. */
41
42 .text
43 .align 4
44 .globl __remqu
45 .type __remqu, @funcnoplt
46 .usepv __remqu, no
47
48 cfi_startproc
49 cfi_return_column (RA)
50__remqu:
51 lda sp, -FRAME(sp)
52 cfi_def_cfa_offset (FRAME)
53 CALL_MCOUNT
54
55 /* Get the fp divide insn issued as quickly as possible. After
56 that's done, we have at least 22 cycles until its results are
57 ready -- all the time in the world to figure out how we're
58 going to use the results. */
59 subq Y, 1, AT
60 stt $f0, 0(sp)
61 and Y, AT, AT
62
63 stt $f1, 8(sp)
64 excb
65 stt $f3, 48(sp)
66 beq AT, $powerof2
67 cfi_rel_offset ($f0, 0)
68 cfi_rel_offset ($f1, 8)
69 cfi_rel_offset ($f3, 48)
70
71 _ITOFT2 X, $f0, 16, Y, $f1, 24
72 mf_fpcr $f3
73 cvtqt $f0, $f0
74 cvtqt $f1, $f1
75
76 blt X, $x_is_neg
77 divt/c $f0, $f1, $f0
78
79 /* Check to see if Y was mis-converted as signed value. */
80 ldt $f1, 8(sp)
81 blt Y, $y_is_neg
82
83 /* Check to see if X fit in the double as an exact value. */
84 srl X, 53, AT
85 bne AT, $x_big
86
87 /* If we get here, we're expecting exact results from the division.
88 Do nothing else besides convert, compute remainder, clean up. */
89 cvttq/c $f0, $f0
90 excb
91 mt_fpcr $f3
92 _FTOIT $f0, AT, 16
93
94 mulq AT, Y, AT
95 ldt $f0, 0(sp)
96 ldt $f3, 48(sp)
97 lda sp, FRAME(sp)
98 cfi_remember_state
99 cfi_restore ($f0)
100 cfi_restore ($f1)
101 cfi_restore ($f3)
102 cfi_def_cfa_offset (0)
103
104 .align 4
105 subq X, AT, RV
106 ret $31, (RA), 1
107
108 .align 4
109 cfi_restore_state
110$x_is_neg:
111 /* If we get here, X is so big that bit 63 is set, which made the
112 conversion come out negative. Fix it up lest we not even get
113 a good estimate. */
114 ldah AT, 0x5f80 /* 2**64 as float. */
115 stt $f2, 24(sp)
116 cfi_rel_offset ($f2, 24)
117 _ITOFS AT, $f2, 16
118
119 addt $f0, $f2, $f0
120 divt/c $f0, $f1, $f0
121
122 /* Ok, we've now the divide issued. Continue with other checks. */
123 .align 4
124 ldt $f1, 8(sp)
125 unop
126 ldt $f2, 24(sp)
127 blt Y, $y_is_neg
128 cfi_restore ($f1)
129 cfi_restore ($f2)
130 cfi_remember_state /* for y_is_neg */
131
132 .align 4
133$x_big:
134 /* If we get here, X is large enough that we don't expect exact
135 results, and neither X nor Y got mis-translated for the fp
136 division. Our task is to take the fp result, figure out how
137 far it's off from the correct result and compute a fixup. */
138 stq t0, 16(sp)
139 stq t1, 24(sp)
140 stq t2, 32(sp)
141 stq t3, 40(sp)
142 cfi_rel_offset (t0, 16)
143 cfi_rel_offset (t1, 24)
144 cfi_rel_offset (t2, 32)
145 cfi_rel_offset (t3, 40)
146
147#define Q t0 /* quotient */
148#define R RV /* remainder */
149#define SY t1 /* scaled Y */
150#define S t2 /* scalar */
151#define QY t3 /* Q*Y */
152
153 cvttq/c $f0, $f0
154 _FTOIT $f0, Q, 8
155 mulq Q, Y, QY
156
157 .align 4
158 stq t4, 8(sp)
159 excb
160 ldt $f0, 0(sp)
161 mt_fpcr $f3
162 cfi_rel_offset (t4, 8)
163 cfi_restore ($f0)
164
165 subq QY, X, R
166 mov Y, SY
167 mov 1, S
168 bgt R, $q_high
169
170$q_high_ret:
171 subq X, QY, R
172 mov Y, SY
173 mov 1, S
174 bgt R, $q_low
175
176$q_low_ret:
177 ldq t4, 8(sp)
178 ldq t0, 16(sp)
179 ldq t1, 24(sp)
180 ldq t2, 32(sp)
181
182 ldq t3, 40(sp)
183 ldt $f3, 48(sp)
184 lda sp, FRAME(sp)
185 cfi_remember_state
186 cfi_restore (t0)
187 cfi_restore (t1)
188 cfi_restore (t2)
189 cfi_restore (t3)
190 cfi_restore (t4)
191 cfi_restore ($f3)
192 cfi_def_cfa_offset (0)
193 ret $31, (RA), 1
194
195 .align 4
196 cfi_restore_state
197 /* The quotient that we computed was too large. We need to reduce
198 it by S such that Y*S >= R. Obviously the closer we get to the
199 correct value the better, but overshooting high is ok, as we'll
200 fix that up later. */
2010:
202 addq SY, SY, SY
203 addq S, S, S
204$q_high:
205 cmpult SY, R, AT
206 bne AT, 0b
207
208 subq Q, S, Q
209 unop
210 subq QY, SY, QY
211 br $q_high_ret
212
213 .align 4
214 /* The quotient that we computed was too small. Divide Y by the
215 current remainder (R) and add that to the existing quotient (Q).
216 The expectation, of course, is that R is much smaller than X. */
217 /* Begin with a shift-up loop. Compute S such that Y*S >= R. We
218 already have a copy of Y in SY and the value 1 in S. */
2190:
220 addq SY, SY, SY
221 addq S, S, S
222$q_low:
223 cmpult SY, R, AT
224 bne AT, 0b
225
226 /* Shift-down and subtract loop. Each iteration compares our scaled
227 Y (SY) with the remainder (R); if SY <= R then X is divisible by
228 Y's scalar (S) so add it to the quotient (Q). */
2292: addq Q, S, t3
230 srl S, 1, S
231 cmpule SY, R, AT
232 subq R, SY, t4
233
234 cmovne AT, t3, Q
235 cmovne AT, t4, R
236 srl SY, 1, SY
237 bne S, 2b
238
239 br $q_low_ret
240
241 .align 4
242 cfi_restore_state
243$y_is_neg:
244 /* If we get here, Y is so big that bit 63 is set. The results
245 from the divide will be completely wrong. Fortunately, the
246 quotient must be either 0 or 1, so the remainder must be X
247 or X-Y, so just compute it directly. */
248 cmpule Y, X, AT
249 excb
250 mt_fpcr $f3
251 subq X, Y, RV
252 ldt $f0, 0(sp)
253 ldt $f3, 48(sp)
254 cmoveq AT, X, RV
255
256 lda sp, FRAME(sp)
257 cfi_restore ($f0)
258 cfi_restore ($f3)
259 cfi_def_cfa_offset (0)
260 ret $31, (RA), 1
261
262 .align 4
263 cfi_def_cfa_offset (FRAME)
264$powerof2:
265 subq Y, 1, AT
266 beq Y, DIVBYZERO
267 and X, AT, RV
268 lda sp, FRAME(sp)
269 cfi_def_cfa_offset (0)
270 ret $31, (RA), 1
271
272 cfi_endproc
273 .size __remqu, .-__remqu
274
275 DO_DIVBYZERO
276

Warning: That file was not part of the compilation database. It may have many parsing errors.