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 divide. 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 __divqu
45 .type __divqu, @funcnoplt
46 .usepv __divqu, no
47
48 cfi_startproc
49 cfi_return_column (RA)
50__divqu:
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 stt $f0, 0(sp)
60 excb
61 beq Y, DIVBYZERO
62
63 stt $f1, 8(sp)
64 stt $f3, 48(sp)
65 cfi_rel_offset ($f0, 0)
66 cfi_rel_offset ($f1, 8)
67 cfi_rel_offset ($f3, 48)
68 mf_fpcr $f3
69
70 _ITOFT2 X, $f0, 16, Y, $f1, 24
71 cvtqt $f0, $f0
72 cvtqt $f1, $f1
73 blt X, $x_is_neg
74 divt/c $f0, $f1, $f0
75
76 /* Check to see if Y was mis-converted as signed value. */
77 ldt $f1, 8(sp)
78 blt Y, $y_is_neg
79
80 /* Check to see if X fit in the double as an exact value. */
81 srl X, 53, AT
82 bne AT, $x_big
83
84 /* If we get here, we're expecting exact results from the division.
85 Do nothing else besides convert and clean up. */
86 cvttq/c $f0, $f0
87 excb
88 mt_fpcr $f3
89 _FTOIT $f0, RV, 16
90
91 ldt $f0, 0(sp)
92 ldt $f3, 48(sp)
93 cfi_remember_state
94 cfi_restore ($f0)
95 cfi_restore ($f1)
96 cfi_restore ($f3)
97 cfi_def_cfa_offset (0)
98 lda sp, FRAME(sp)
99 ret $31, (RA), 1
100
101 .align 4
102 cfi_restore_state
103$x_is_neg:
104 /* If we get here, X is so big that bit 63 is set, which made the
105 conversion come out negative. Fix it up lest we not even get
106 a good estimate. */
107 ldah AT, 0x5f80 /* 2**64 as float. */
108 stt $f2, 24(sp)
109 cfi_rel_offset ($f2, 24)
110 _ITOFS AT, $f2, 16
111
112 .align 4
113 addt $f0, $f2, $f0
114 unop
115 divt/c $f0, $f1, $f0
116 unop
117
118 /* Ok, we've now the divide issued. Continue with other checks. */
119 ldt $f1, 8(sp)
120 unop
121 ldt $f2, 24(sp)
122 blt Y, $y_is_neg
123 cfi_restore ($f1)
124 cfi_restore ($f2)
125 cfi_remember_state /* for y_is_neg */
126
127 .align 4
128$x_big:
129 /* If we get here, X is large enough that we don't expect exact
130 results, and neither X nor Y got mis-translated for the fp
131 division. Our task is to take the fp result, figure out how
132 far it's off from the correct result and compute a fixup. */
133 stq t0, 16(sp)
134 stq t1, 24(sp)
135 stq t2, 32(sp)
136 stq t3, 40(sp)
137 cfi_rel_offset (t0, 16)
138 cfi_rel_offset (t1, 24)
139 cfi_rel_offset (t2, 32)
140 cfi_rel_offset (t3, 40)
141
142#define Q RV /* quotient */
143#define R t0 /* remainder */
144#define SY t1 /* scaled Y */
145#define S t2 /* scalar */
146#define QY t3 /* Q*Y */
147
148 cvttq/c $f0, $f0
149 _FTOIT $f0, Q, 8
150 mulq Q, Y, QY
151
152 .align 4
153 stq t4, 8(sp)
154 excb
155 ldt $f0, 0(sp)
156 mt_fpcr $f3
157 cfi_rel_offset (t4, 8)
158 cfi_restore ($f0)
159
160 subq QY, X, R
161 mov Y, SY
162 mov 1, S
163 bgt R, $q_high
164
165$q_high_ret:
166 subq X, QY, R
167 mov Y, SY
168 mov 1, S
169 bgt R, $q_low
170
171$q_low_ret:
172 ldq t4, 8(sp)
173 ldq t0, 16(sp)
174 ldq t1, 24(sp)
175 ldq t2, 32(sp)
176
177 ldq t3, 40(sp)
178 ldt $f3, 48(sp)
179 lda sp, FRAME(sp)
180 cfi_remember_state
181 cfi_restore (t0)
182 cfi_restore (t1)
183 cfi_restore (t2)
184 cfi_restore (t3)
185 cfi_restore (t4)
186 cfi_restore ($f3)
187 cfi_def_cfa_offset (0)
188 ret $31, (RA), 1
189
190 .align 4
191 cfi_restore_state
192 /* The quotient that we computed was too large. We need to reduce
193 it by S such that Y*S >= R. Obviously the closer we get to the
194 correct value the better, but overshooting high is ok, as we'll
195 fix that up later. */
1960:
197 addq SY, SY, SY
198 addq S, S, S
199$q_high:
200 cmpult SY, R, AT
201 bne AT, 0b
202
203 subq Q, S, Q
204 unop
205 subq QY, SY, QY
206 br $q_high_ret
207
208 .align 4
209 /* The quotient that we computed was too small. Divide Y by the
210 current remainder (R) and add that to the existing quotient (Q).
211 The expectation, of course, is that R is much smaller than X. */
212 /* Begin with a shift-up loop. Compute S such that Y*S >= R. We
213 already have a copy of Y in SY and the value 1 in S. */
2140:
215 addq SY, SY, SY
216 addq S, S, S
217$q_low:
218 cmpult SY, R, AT
219 bne AT, 0b
220
221 /* Shift-down and subtract loop. Each iteration compares our scaled
222 Y (SY) with the remainder (R); if SY <= R then X is divisible by
223 Y's scalar (S) so add it to the quotient (Q). */
2242: addq Q, S, t3
225 srl S, 1, S
226 cmpule SY, R, AT
227 subq R, SY, t4
228
229 cmovne AT, t3, Q
230 cmovne AT, t4, R
231 srl SY, 1, SY
232 bne S, 2b
233
234 br $q_low_ret
235
236 .align 4
237 cfi_restore_state
238$y_is_neg:
239 /* If we get here, Y is so big that bit 63 is set. The results
240 from the divide will be completely wrong. Fortunately, the
241 quotient must be either 0 or 1, so just compute it directly. */
242 cmpule Y, X, RV
243 excb
244 mt_fpcr $f3
245 ldt $f0, 0(sp)
246 ldt $f3, 48(sp)
247 lda sp, FRAME(sp)
248 cfi_restore ($f0)
249 cfi_restore ($f3)
250 cfi_def_cfa_offset (0)
251 ret $31, (RA), 1
252
253 cfi_endproc
254 .size __divqu, .-__divqu
255
256 DO_DIVBYZERO
257

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