|
0
|
1 /* IEEE-754 double-precision functions for Xtensa
|
|
|
2 Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
|
|
|
3 Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it
|
|
|
8 under the terms of the GNU General Public License as published by
|
|
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
|
10 any later version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
|
15 License for more details.
|
|
|
16
|
|
|
17 Under Section 7 of GPL version 3, you are granted additional
|
|
|
18 permissions described in the GCC Runtime Library Exception, version
|
|
|
19 3.1, as published by the Free Software Foundation.
|
|
|
20
|
|
|
21 You should have received a copy of the GNU General Public License and
|
|
|
22 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
24 <http://www.gnu.org/licenses/>. */
|
|
|
25
|
|
|
26 #ifdef __XTENSA_EB__
|
|
|
27 #define xh a2
|
|
|
28 #define xl a3
|
|
|
29 #define yh a4
|
|
|
30 #define yl a5
|
|
|
31 #else
|
|
|
32 #define xh a3
|
|
|
33 #define xl a2
|
|
|
34 #define yh a5
|
|
|
35 #define yl a4
|
|
|
36 #endif
|
|
|
37
|
|
|
38 /* Warning! The branch displacements for some Xtensa branch instructions
|
|
|
39 are quite small, and this code has been carefully laid out to keep
|
|
|
40 branch targets in range. If you change anything, be sure to check that
|
|
|
41 the assembler is not relaxing anything to branch over a jump. */
|
|
|
42
|
|
|
43 #ifdef L_negdf2
|
|
|
44
|
|
|
45 .align 4
|
|
|
46 .global __negdf2
|
|
|
47 .type __negdf2, @function
|
|
|
48 __negdf2:
|
|
|
49 leaf_entry sp, 16
|
|
|
50 movi a4, 0x80000000
|
|
|
51 xor xh, xh, a4
|
|
|
52 leaf_return
|
|
|
53
|
|
|
54 #endif /* L_negdf2 */
|
|
|
55
|
|
|
56 #ifdef L_addsubdf3
|
|
|
57
|
|
|
58 /* Addition */
|
|
|
59 __adddf3_aux:
|
|
|
60
|
|
|
61 /* Handle NaNs and Infinities. (This code is placed before the
|
|
|
62 start of the function just to keep it in range of the limited
|
|
|
63 branch displacements.) */
|
|
|
64
|
|
|
65 .Ladd_xnan_or_inf:
|
|
|
66 /* If y is neither Infinity nor NaN, return x. */
|
|
|
67 bnall yh, a6, 1f
|
|
|
68 /* If x is a NaN, return it. Otherwise, return y. */
|
|
|
69 slli a7, xh, 12
|
|
|
70 or a7, a7, xl
|
|
|
71 beqz a7, .Ladd_ynan_or_inf
|
|
|
72 1: leaf_return
|
|
|
73
|
|
|
74 .Ladd_ynan_or_inf:
|
|
|
75 /* Return y. */
|
|
|
76 mov xh, yh
|
|
|
77 mov xl, yl
|
|
|
78 leaf_return
|
|
|
79
|
|
|
80 .Ladd_opposite_signs:
|
|
|
81 /* Operand signs differ. Do a subtraction. */
|
|
|
82 slli a7, a6, 11
|
|
|
83 xor yh, yh, a7
|
|
|
84 j .Lsub_same_sign
|
|
|
85
|
|
|
86 .align 4
|
|
|
87 .global __adddf3
|
|
|
88 .type __adddf3, @function
|
|
|
89 __adddf3:
|
|
|
90 leaf_entry sp, 16
|
|
|
91 movi a6, 0x7ff00000
|
|
|
92
|
|
|
93 /* Check if the two operands have the same sign. */
|
|
|
94 xor a7, xh, yh
|
|
|
95 bltz a7, .Ladd_opposite_signs
|
|
|
96
|
|
|
97 .Ladd_same_sign:
|
|
|
98 /* Check if either exponent == 0x7ff (i.e., NaN or Infinity). */
|
|
|
99 ball xh, a6, .Ladd_xnan_or_inf
|
|
|
100 ball yh, a6, .Ladd_ynan_or_inf
|
|
|
101
|
|
|
102 /* Compare the exponents. The smaller operand will be shifted
|
|
|
103 right by the exponent difference and added to the larger
|
|
|
104 one. */
|
|
|
105 extui a7, xh, 20, 12
|
|
|
106 extui a8, yh, 20, 12
|
|
|
107 bltu a7, a8, .Ladd_shiftx
|
|
|
108
|
|
|
109 .Ladd_shifty:
|
|
|
110 /* Check if the smaller (or equal) exponent is zero. */
|
|
|
111 bnone yh, a6, .Ladd_yexpzero
|
|
|
112
|
|
|
113 /* Replace yh sign/exponent with 0x001. */
|
|
|
114 or yh, yh, a6
|
|
|
115 slli yh, yh, 11
|
|
|
116 srli yh, yh, 11
|
|
|
117
|
|
|
118 .Ladd_yexpdiff:
|
|
|
119 /* Compute the exponent difference. Optimize for difference < 32. */
|
|
|
120 sub a10, a7, a8
|
|
|
121 bgeui a10, 32, .Ladd_bigshifty
|
|
|
122
|
|
|
123 /* Shift yh/yl right by the exponent difference. Any bits that are
|
|
|
124 shifted out of yl are saved in a9 for rounding the result. */
|
|
|
125 ssr a10
|
|
|
126 movi a9, 0
|
|
|
127 src a9, yl, a9
|
|
|
128 src yl, yh, yl
|
|
|
129 srl yh, yh
|
|
|
130
|
|
|
131 .Ladd_addy:
|
|
|
132 /* Do the 64-bit addition. */
|
|
|
133 add xl, xl, yl
|
|
|
134 add xh, xh, yh
|
|
|
135 bgeu xl, yl, 1f
|
|
|
136 addi xh, xh, 1
|
|
|
137 1:
|
|
|
138 /* Check if the add overflowed into the exponent. */
|
|
|
139 extui a10, xh, 20, 12
|
|
|
140 beq a10, a7, .Ladd_round
|
|
|
141 mov a8, a7
|
|
|
142 j .Ladd_carry
|
|
|
143
|
|
|
144 .Ladd_yexpzero:
|
|
|
145 /* y is a subnormal value. Replace its sign/exponent with zero,
|
|
|
146 i.e., no implicit "1.0", and increment the apparent exponent
|
|
|
147 because subnormals behave as if they had the minimum (nonzero)
|
|
|
148 exponent. Test for the case when both exponents are zero. */
|
|
|
149 slli yh, yh, 12
|
|
|
150 srli yh, yh, 12
|
|
|
151 bnone xh, a6, .Ladd_bothexpzero
|
|
|
152 addi a8, a8, 1
|
|
|
153 j .Ladd_yexpdiff
|
|
|
154
|
|
|
155 .Ladd_bothexpzero:
|
|
|
156 /* Both exponents are zero. Handle this as a special case. There
|
|
|
157 is no need to shift or round, and the normal code for handling
|
|
|
158 a carry into the exponent field will not work because it
|
|
|
159 assumes there is an implicit "1.0" that needs to be added. */
|
|
|
160 add xl, xl, yl
|
|
|
161 add xh, xh, yh
|
|
|
162 bgeu xl, yl, 1f
|
|
|
163 addi xh, xh, 1
|
|
|
164 1: leaf_return
|
|
|
165
|
|
|
166 .Ladd_bigshifty:
|
|
|
167 /* Exponent difference > 64 -- just return the bigger value. */
|
|
|
168 bgeui a10, 64, 1b
|
|
|
169
|
|
|
170 /* Shift yh/yl right by the exponent difference. Any bits that are
|
|
|
171 shifted out are saved in a9 for rounding the result. */
|
|
|
172 ssr a10
|
|
|
173 sll a11, yl /* lost bits shifted out of yl */
|
|
|
174 src a9, yh, yl
|
|
|
175 srl yl, yh
|
|
|
176 movi yh, 0
|
|
|
177 beqz a11, .Ladd_addy
|
|
|
178 or a9, a9, a10 /* any positive, nonzero value will work */
|
|
|
179 j .Ladd_addy
|
|
|
180
|
|
|
181 .Ladd_xexpzero:
|
|
|
182 /* Same as "yexpzero" except skip handling the case when both
|
|
|
183 exponents are zero. */
|
|
|
184 slli xh, xh, 12
|
|
|
185 srli xh, xh, 12
|
|
|
186 addi a7, a7, 1
|
|
|
187 j .Ladd_xexpdiff
|
|
|
188
|
|
|
189 .Ladd_shiftx:
|
|
|
190 /* Same thing as the "shifty" code, but with x and y swapped. Also,
|
|
|
191 because the exponent difference is always nonzero in this version,
|
|
|
192 the shift sequence can use SLL and skip loading a constant zero. */
|
|
|
193 bnone xh, a6, .Ladd_xexpzero
|
|
|
194
|
|
|
195 or xh, xh, a6
|
|
|
196 slli xh, xh, 11
|
|
|
197 srli xh, xh, 11
|
|
|
198
|
|
|
199 .Ladd_xexpdiff:
|
|
|
200 sub a10, a8, a7
|
|
|
201 bgeui a10, 32, .Ladd_bigshiftx
|
|
|
202
|
|
|
203 ssr a10
|
|
|
204 sll a9, xl
|
|
|
205 src xl, xh, xl
|
|
|
206 srl xh, xh
|
|
|
207
|
|
|
208 .Ladd_addx:
|
|
|
209 add xl, xl, yl
|
|
|
210 add xh, xh, yh
|
|
|
211 bgeu xl, yl, 1f
|
|
|
212 addi xh, xh, 1
|
|
|
213 1:
|
|
|
214 /* Check if the add overflowed into the exponent. */
|
|
|
215 extui a10, xh, 20, 12
|
|
|
216 bne a10, a8, .Ladd_carry
|
|
|
217
|
|
|
218 .Ladd_round:
|
|
|
219 /* Round up if the leftover fraction is >= 1/2. */
|
|
|
220 bgez a9, 1f
|
|
|
221 addi xl, xl, 1
|
|
|
222 beqz xl, .Ladd_roundcarry
|
|
|
223
|
|
|
224 /* Check if the leftover fraction is exactly 1/2. */
|
|
|
225 slli a9, a9, 1
|
|
|
226 beqz a9, .Ladd_exactlyhalf
|
|
|
227 1: leaf_return
|
|
|
228
|
|
|
229 .Ladd_bigshiftx:
|
|
|
230 /* Mostly the same thing as "bigshifty".... */
|
|
|
231 bgeui a10, 64, .Ladd_returny
|
|
|
232
|
|
|
233 ssr a10
|
|
|
234 sll a11, xl
|
|
|
235 src a9, xh, xl
|
|
|
236 srl xl, xh
|
|
|
237 movi xh, 0
|
|
|
238 beqz a11, .Ladd_addx
|
|
|
239 or a9, a9, a10
|
|
|
240 j .Ladd_addx
|
|
|
241
|
|
|
242 .Ladd_returny:
|
|
|
243 mov xh, yh
|
|
|
244 mov xl, yl
|
|
|
245 leaf_return
|
|
|
246
|
|
|
247 .Ladd_carry:
|
|
|
248 /* The addition has overflowed into the exponent field, so the
|
|
|
249 value needs to be renormalized. The mantissa of the result
|
|
|
250 can be recovered by subtracting the original exponent and
|
|
|
251 adding 0x100000 (which is the explicit "1.0" for the
|
|
|
252 mantissa of the non-shifted operand -- the "1.0" for the
|
|
|
253 shifted operand was already added). The mantissa can then
|
|
|
254 be shifted right by one bit. The explicit "1.0" of the
|
|
|
255 shifted mantissa then needs to be replaced by the exponent,
|
|
|
256 incremented by one to account for the normalizing shift.
|
|
|
257 It is faster to combine these operations: do the shift first
|
|
|
258 and combine the additions and subtractions. If x is the
|
|
|
259 original exponent, the result is:
|
|
|
260 shifted mantissa - (x << 19) + (1 << 19) + (x << 20)
|
|
|
261 or:
|
|
|
262 shifted mantissa + ((x + 1) << 19)
|
|
|
263 Note that the exponent is incremented here by leaving the
|
|
|
264 explicit "1.0" of the mantissa in the exponent field. */
|
|
|
265
|
|
|
266 /* Shift xh/xl right by one bit. Save the lsb of xl. */
|
|
|
267 mov a10, xl
|
|
|
268 ssai 1
|
|
|
269 src xl, xh, xl
|
|
|
270 srl xh, xh
|
|
|
271
|
|
|
272 /* See explanation above. The original exponent is in a8. */
|
|
|
273 addi a8, a8, 1
|
|
|
274 slli a8, a8, 19
|
|
|
275 add xh, xh, a8
|
|
|
276
|
|
|
277 /* Return an Infinity if the exponent overflowed. */
|
|
|
278 ball xh, a6, .Ladd_infinity
|
|
|
279
|
|
|
280 /* Same thing as the "round" code except the msb of the leftover
|
|
|
281 fraction is bit 0 of a10, with the rest of the fraction in a9. */
|
|
|
282 bbci.l a10, 0, 1f
|
|
|
283 addi xl, xl, 1
|
|
|
284 beqz xl, .Ladd_roundcarry
|
|
|
285 beqz a9, .Ladd_exactlyhalf
|
|
|
286 1: leaf_return
|
|
|
287
|
|
|
288 .Ladd_infinity:
|
|
|
289 /* Clear the mantissa. */
|
|
|
290 movi xl, 0
|
|
|
291 srli xh, xh, 20
|
|
|
292 slli xh, xh, 20
|
|
|
293
|
|
|
294 /* The sign bit may have been lost in a carry-out. Put it back. */
|
|
|
295 slli a8, a8, 1
|
|
|
296 or xh, xh, a8
|
|
|
297 leaf_return
|
|
|
298
|
|
|
299 .Ladd_exactlyhalf:
|
|
|
300 /* Round down to the nearest even value. */
|
|
|
301 srli xl, xl, 1
|
|
|
302 slli xl, xl, 1
|
|
|
303 leaf_return
|
|
|
304
|
|
|
305 .Ladd_roundcarry:
|
|
|
306 /* xl is always zero when the rounding increment overflows, so
|
|
|
307 there's no need to round it to an even value. */
|
|
|
308 addi xh, xh, 1
|
|
|
309 /* Overflow to the exponent is OK. */
|
|
|
310 leaf_return
|
|
|
311
|
|
|
312
|
|
|
313 /* Subtraction */
|
|
|
314 __subdf3_aux:
|
|
|
315
|
|
|
316 /* Handle NaNs and Infinities. (This code is placed before the
|
|
|
317 start of the function just to keep it in range of the limited
|
|
|
318 branch displacements.) */
|
|
|
319
|
|
|
320 .Lsub_xnan_or_inf:
|
|
|
321 /* If y is neither Infinity nor NaN, return x. */
|
|
|
322 bnall yh, a6, 1f
|
|
|
323 /* Both x and y are either NaN or Inf, so the result is NaN. */
|
|
|
324 movi a4, 0x80000 /* make it a quiet NaN */
|
|
|
325 or xh, xh, a4
|
|
|
326 1: leaf_return
|
|
|
327
|
|
|
328 .Lsub_ynan_or_inf:
|
|
|
329 /* Negate y and return it. */
|
|
|
330 slli a7, a6, 11
|
|
|
331 xor xh, yh, a7
|
|
|
332 mov xl, yl
|
|
|
333 leaf_return
|
|
|
334
|
|
|
335 .Lsub_opposite_signs:
|
|
|
336 /* Operand signs differ. Do an addition. */
|
|
|
337 slli a7, a6, 11
|
|
|
338 xor yh, yh, a7
|
|
|
339 j .Ladd_same_sign
|
|
|
340
|
|
|
341 .align 4
|
|
|
342 .global __subdf3
|
|
|
343 .type __subdf3, @function
|
|
|
344 __subdf3:
|
|
|
345 leaf_entry sp, 16
|
|
|
346 movi a6, 0x7ff00000
|
|
|
347
|
|
|
348 /* Check if the two operands have the same sign. */
|
|
|
349 xor a7, xh, yh
|
|
|
350 bltz a7, .Lsub_opposite_signs
|
|
|
351
|
|
|
352 .Lsub_same_sign:
|
|
|
353 /* Check if either exponent == 0x7ff (i.e., NaN or Infinity). */
|
|
|
354 ball xh, a6, .Lsub_xnan_or_inf
|
|
|
355 ball yh, a6, .Lsub_ynan_or_inf
|
|
|
356
|
|
|
357 /* Compare the operands. In contrast to addition, the entire
|
|
|
358 value matters here. */
|
|
|
359 extui a7, xh, 20, 11
|
|
|
360 extui a8, yh, 20, 11
|
|
|
361 bltu xh, yh, .Lsub_xsmaller
|
|
|
362 beq xh, yh, .Lsub_compare_low
|
|
|
363
|
|
|
364 .Lsub_ysmaller:
|
|
|
365 /* Check if the smaller (or equal) exponent is zero. */
|
|
|
366 bnone yh, a6, .Lsub_yexpzero
|
|
|
367
|
|
|
368 /* Replace yh sign/exponent with 0x001. */
|
|
|
369 or yh, yh, a6
|
|
|
370 slli yh, yh, 11
|
|
|
371 srli yh, yh, 11
|
|
|
372
|
|
|
373 .Lsub_yexpdiff:
|
|
|
374 /* Compute the exponent difference. Optimize for difference < 32. */
|
|
|
375 sub a10, a7, a8
|
|
|
376 bgeui a10, 32, .Lsub_bigshifty
|
|
|
377
|
|
|
378 /* Shift yh/yl right by the exponent difference. Any bits that are
|
|
|
379 shifted out of yl are saved in a9 for rounding the result. */
|
|
|
380 ssr a10
|
|
|
381 movi a9, 0
|
|
|
382 src a9, yl, a9
|
|
|
383 src yl, yh, yl
|
|
|
384 srl yh, yh
|
|
|
385
|
|
|
386 .Lsub_suby:
|
|
|
387 /* Do the 64-bit subtraction. */
|
|
|
388 sub xh, xh, yh
|
|
|
389 bgeu xl, yl, 1f
|
|
|
390 addi xh, xh, -1
|
|
|
391 1: sub xl, xl, yl
|
|
|
392
|
|
|
393 /* Subtract the leftover bits in a9 from zero and propagate any
|
|
|
394 borrow from xh/xl. */
|
|
|
395 neg a9, a9
|
|
|
396 beqz a9, 1f
|
|
|
397 addi a5, xh, -1
|
|
|
398 moveqz xh, a5, xl
|
|
|
399 addi xl, xl, -1
|
|
|
400 1:
|
|
|
401 /* Check if the subtract underflowed into the exponent. */
|
|
|
402 extui a10, xh, 20, 11
|
|
|
403 beq a10, a7, .Lsub_round
|
|
|
404 j .Lsub_borrow
|
|
|
405
|
|
|
406 .Lsub_compare_low:
|
|
|
407 /* The high words are equal. Compare the low words. */
|
|
|
408 bltu xl, yl, .Lsub_xsmaller
|
|
|
409 bltu yl, xl, .Lsub_ysmaller
|
|
|
410 /* The operands are equal. Return 0.0. */
|
|
|
411 movi xh, 0
|
|
|
412 movi xl, 0
|
|
|
413 1: leaf_return
|
|
|
414
|
|
|
415 .Lsub_yexpzero:
|
|
|
416 /* y is a subnormal value. Replace its sign/exponent with zero,
|
|
|
417 i.e., no implicit "1.0". Unless x is also a subnormal, increment
|
|
|
418 y's apparent exponent because subnormals behave as if they had
|
|
|
419 the minimum (nonzero) exponent. */
|
|
|
420 slli yh, yh, 12
|
|
|
421 srli yh, yh, 12
|
|
|
422 bnone xh, a6, .Lsub_yexpdiff
|
|
|
423 addi a8, a8, 1
|
|
|
424 j .Lsub_yexpdiff
|
|
|
425
|
|
|
426 .Lsub_bigshifty:
|
|
|
427 /* Exponent difference > 64 -- just return the bigger value. */
|
|
|
428 bgeui a10, 64, 1b
|
|
|
429
|
|
|
430 /* Shift yh/yl right by the exponent difference. Any bits that are
|
|
|
431 shifted out are saved in a9 for rounding the result. */
|
|
|
432 ssr a10
|
|
|
433 sll a11, yl /* lost bits shifted out of yl */
|
|
|
434 src a9, yh, yl
|
|
|
435 srl yl, yh
|
|
|
436 movi yh, 0
|
|
|
437 beqz a11, .Lsub_suby
|
|
|
438 or a9, a9, a10 /* any positive, nonzero value will work */
|
|
|
439 j .Lsub_suby
|
|
|
440
|
|
|
441 .Lsub_xsmaller:
|
|
|
442 /* Same thing as the "ysmaller" code, but with x and y swapped and
|
|
|
443 with y negated. */
|
|
|
444 bnone xh, a6, .Lsub_xexpzero
|
|
|
445
|
|
|
446 or xh, xh, a6
|
|
|
447 slli xh, xh, 11
|
|
|
448 srli xh, xh, 11
|
|
|
449
|
|
|
450 .Lsub_xexpdiff:
|
|
|
451 sub a10, a8, a7
|
|
|
452 bgeui a10, 32, .Lsub_bigshiftx
|
|
|
453
|
|
|
454 ssr a10
|
|
|
455 movi a9, 0
|
|
|
456 src a9, xl, a9
|
|
|
457 src xl, xh, xl
|
|
|
458 srl xh, xh
|
|
|
459
|
|
|
460 /* Negate y. */
|
|
|
461 slli a11, a6, 11
|
|
|
462 xor yh, yh, a11
|
|
|
463
|
|
|
464 .Lsub_subx:
|
|
|
465 sub xl, yl, xl
|
|
|
466 sub xh, yh, xh
|
|
|
467 bgeu yl, xl, 1f
|
|
|
468 addi xh, xh, -1
|
|
|
469 1:
|
|
|
470 /* Subtract the leftover bits in a9 from zero and propagate any
|
|
|
471 borrow from xh/xl. */
|
|
|
472 neg a9, a9
|
|
|
473 beqz a9, 1f
|
|
|
474 addi a5, xh, -1
|
|
|
475 moveqz xh, a5, xl
|
|
|
476 addi xl, xl, -1
|
|
|
477 1:
|
|
|
478 /* Check if the subtract underflowed into the exponent. */
|
|
|
479 extui a10, xh, 20, 11
|
|
|
480 bne a10, a8, .Lsub_borrow
|
|
|
481
|
|
|
482 .Lsub_round:
|
|
|
483 /* Round up if the leftover fraction is >= 1/2. */
|
|
|
484 bgez a9, 1f
|
|
|
485 addi xl, xl, 1
|
|
|
486 beqz xl, .Lsub_roundcarry
|
|
|
487
|
|
|
488 /* Check if the leftover fraction is exactly 1/2. */
|
|
|
489 slli a9, a9, 1
|
|
|
490 beqz a9, .Lsub_exactlyhalf
|
|
|
491 1: leaf_return
|
|
|
492
|
|
|
493 .Lsub_xexpzero:
|
|
|
494 /* Same as "yexpzero". */
|
|
|
495 slli xh, xh, 12
|
|
|
496 srli xh, xh, 12
|
|
|
497 bnone yh, a6, .Lsub_xexpdiff
|
|
|
498 addi a7, a7, 1
|
|
|
499 j .Lsub_xexpdiff
|
|
|
500
|
|
|
501 .Lsub_bigshiftx:
|
|
|
502 /* Mostly the same thing as "bigshifty", but with the sign bit of the
|
|
|
503 shifted value set so that the subsequent subtraction flips the
|
|
|
504 sign of y. */
|
|
|
505 bgeui a10, 64, .Lsub_returny
|
|
|
506
|
|
|
507 ssr a10
|
|
|
508 sll a11, xl
|
|
|
509 src a9, xh, xl
|
|
|
510 srl xl, xh
|
|
|
511 slli xh, a6, 11 /* set sign bit of xh */
|
|
|
512 beqz a11, .Lsub_subx
|
|
|
513 or a9, a9, a10
|
|
|
514 j .Lsub_subx
|
|
|
515
|
|
|
516 .Lsub_returny:
|
|
|
517 /* Negate and return y. */
|
|
|
518 slli a7, a6, 11
|
|
|
519 xor xh, yh, a7
|
|
|
520 mov xl, yl
|
|
|
521 leaf_return
|
|
|
522
|
|
|
523 .Lsub_borrow:
|
|
|
524 /* The subtraction has underflowed into the exponent field, so the
|
|
|
525 value needs to be renormalized. Shift the mantissa left as
|
|
|
526 needed to remove any leading zeros and adjust the exponent
|
|
|
527 accordingly. If the exponent is not large enough to remove
|
|
|
528 all the leading zeros, the result will be a subnormal value. */
|
|
|
529
|
|
|
530 slli a8, xh, 12
|
|
|
531 beqz a8, .Lsub_xhzero
|
|
|
532 do_nsau a6, a8, a7, a11
|
|
|
533 srli a8, a8, 12
|
|
|
534 bge a6, a10, .Lsub_subnormal
|
|
|
535 addi a6, a6, 1
|
|
|
536
|
|
|
537 .Lsub_shift_lt32:
|
|
|
538 /* Shift the mantissa (a8/xl/a9) left by a6. */
|
|
|
539 ssl a6
|
|
|
540 src a8, a8, xl
|
|
|
541 src xl, xl, a9
|
|
|
542 sll a9, a9
|
|
|
543
|
|
|
544 /* Combine the shifted mantissa with the sign and exponent,
|
|
|
545 decrementing the exponent by a6. (The exponent has already
|
|
|
546 been decremented by one due to the borrow from the subtraction,
|
|
|
547 but adding the mantissa will increment the exponent by one.) */
|
|
|
548 srli xh, xh, 20
|
|
|
549 sub xh, xh, a6
|
|
|
550 slli xh, xh, 20
|
|
|
551 add xh, xh, a8
|
|
|
552 j .Lsub_round
|
|
|
553
|
|
|
554 .Lsub_exactlyhalf:
|
|
|
555 /* Round down to the nearest even value. */
|
|
|
556 srli xl, xl, 1
|
|
|
557 slli xl, xl, 1
|
|
|
558 leaf_return
|
|
|
559
|
|
|
560 .Lsub_roundcarry:
|
|
|
561 /* xl is always zero when the rounding increment overflows, so
|
|
|
562 there's no need to round it to an even value. */
|
|
|
563 addi xh, xh, 1
|
|
|
564 /* Overflow to the exponent is OK. */
|
|
|
565 leaf_return
|
|
|
566
|
|
|
567 .Lsub_xhzero:
|
|
|
568 /* When normalizing the result, all the mantissa bits in the high
|
|
|
569 word are zero. Shift by "20 + (leading zero count of xl) + 1". */
|
|
|
570 do_nsau a6, xl, a7, a11
|
|
|
571 addi a6, a6, 21
|
|
|
572 blt a10, a6, .Lsub_subnormal
|
|
|
573
|
|
|
574 .Lsub_normalize_shift:
|
|
|
575 bltui a6, 32, .Lsub_shift_lt32
|
|
|
576
|
|
|
577 ssl a6
|
|
|
578 src a8, xl, a9
|
|
|
579 sll xl, a9
|
|
|
580 movi a9, 0
|
|
|
581
|
|
|
582 srli xh, xh, 20
|
|
|
583 sub xh, xh, a6
|
|
|
584 slli xh, xh, 20
|
|
|
585 add xh, xh, a8
|
|
|
586 j .Lsub_round
|
|
|
587
|
|
|
588 .Lsub_subnormal:
|
|
|
589 /* The exponent is too small to shift away all the leading zeros.
|
|
|
590 Set a6 to the current exponent (which has already been
|
|
|
591 decremented by the borrow) so that the exponent of the result
|
|
|
592 will be zero. Do not add 1 to a6 in this case, because: (1)
|
|
|
593 adding the mantissa will not increment the exponent, so there is
|
|
|
594 no need to subtract anything extra from the exponent to
|
|
|
595 compensate, and (2) the effective exponent of a subnormal is 1
|
|
|
596 not 0 so the shift amount must be 1 smaller than normal. */
|
|
|
597 mov a6, a10
|
|
|
598 j .Lsub_normalize_shift
|
|
|
599
|
|
|
600 #endif /* L_addsubdf3 */
|
|
|
601
|
|
|
602 #ifdef L_muldf3
|
|
|
603
|
|
|
604 /* Multiplication */
|
|
|
605 #if !XCHAL_HAVE_MUL16 && !XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MAC16
|
|
|
606 #define XCHAL_NO_MUL 1
|
|
|
607 #endif
|
|
|
608
|
|
|
609 __muldf3_aux:
|
|
|
610
|
|
|
611 /* Handle unusual cases (zeros, subnormals, NaNs and Infinities).
|
|
|
612 (This code is placed before the start of the function just to
|
|
|
613 keep it in range of the limited branch displacements.) */
|
|
|
614
|
|
|
615 .Lmul_xexpzero:
|
|
|
616 /* Clear the sign bit of x. */
|
|
|
617 slli xh, xh, 1
|
|
|
618 srli xh, xh, 1
|
|
|
619
|
|
|
620 /* If x is zero, return zero. */
|
|
|
621 or a10, xh, xl
|
|
|
622 beqz a10, .Lmul_return_zero
|
|
|
623
|
|
|
624 /* Normalize x. Adjust the exponent in a8. */
|
|
|
625 beqz xh, .Lmul_xh_zero
|
|
|
626 do_nsau a10, xh, a11, a12
|
|
|
627 addi a10, a10, -11
|
|
|
628 ssl a10
|
|
|
629 src xh, xh, xl
|
|
|
630 sll xl, xl
|
|
|
631 movi a8, 1
|
|
|
632 sub a8, a8, a10
|
|
|
633 j .Lmul_xnormalized
|
|
|
634 .Lmul_xh_zero:
|
|
|
635 do_nsau a10, xl, a11, a12
|
|
|
636 addi a10, a10, -11
|
|
|
637 movi a8, -31
|
|
|
638 sub a8, a8, a10
|
|
|
639 ssl a10
|
|
|
640 bltz a10, .Lmul_xl_srl
|
|
|
641 sll xh, xl
|
|
|
642 movi xl, 0
|
|
|
643 j .Lmul_xnormalized
|
|
|
644 .Lmul_xl_srl:
|
|
|
645 srl xh, xl
|
|
|
646 sll xl, xl
|
|
|
647 j .Lmul_xnormalized
|
|
|
648
|
|
|
649 .Lmul_yexpzero:
|
|
|
650 /* Clear the sign bit of y. */
|
|
|
651 slli yh, yh, 1
|
|
|
652 srli yh, yh, 1
|
|
|
653
|
|
|
654 /* If y is zero, return zero. */
|
|
|
655 or a10, yh, yl
|
|
|
656 beqz a10, .Lmul_return_zero
|
|
|
657
|
|
|
658 /* Normalize y. Adjust the exponent in a9. */
|
|
|
659 beqz yh, .Lmul_yh_zero
|
|
|
660 do_nsau a10, yh, a11, a12
|
|
|
661 addi a10, a10, -11
|
|
|
662 ssl a10
|
|
|
663 src yh, yh, yl
|
|
|
664 sll yl, yl
|
|
|
665 movi a9, 1
|
|
|
666 sub a9, a9, a10
|
|
|
667 j .Lmul_ynormalized
|
|
|
668 .Lmul_yh_zero:
|
|
|
669 do_nsau a10, yl, a11, a12
|
|
|
670 addi a10, a10, -11
|
|
|
671 movi a9, -31
|
|
|
672 sub a9, a9, a10
|
|
|
673 ssl a10
|
|
|
674 bltz a10, .Lmul_yl_srl
|
|
|
675 sll yh, yl
|
|
|
676 movi yl, 0
|
|
|
677 j .Lmul_ynormalized
|
|
|
678 .Lmul_yl_srl:
|
|
|
679 srl yh, yl
|
|
|
680 sll yl, yl
|
|
|
681 j .Lmul_ynormalized
|
|
|
682
|
|
|
683 .Lmul_return_zero:
|
|
|
684 /* Return zero with the appropriate sign bit. */
|
|
|
685 srli xh, a7, 31
|
|
|
686 slli xh, xh, 31
|
|
|
687 movi xl, 0
|
|
|
688 j .Lmul_done
|
|
|
689
|
|
|
690 .Lmul_xnan_or_inf:
|
|
|
691 /* If y is zero, return NaN. */
|
|
|
692 bnez yl, 1f
|
|
|
693 slli a8, yh, 1
|
|
|
694 bnez a8, 1f
|
|
|
695 movi a4, 0x80000 /* make it a quiet NaN */
|
|
|
696 or xh, xh, a4
|
|
|
697 j .Lmul_done
|
|
|
698 1:
|
|
|
699 /* If y is NaN, return y. */
|
|
|
700 bnall yh, a6, .Lmul_returnx
|
|
|
701 slli a8, yh, 12
|
|
|
702 or a8, a8, yl
|
|
|
703 beqz a8, .Lmul_returnx
|
|
|
704
|
|
|
705 .Lmul_returny:
|
|
|
706 mov xh, yh
|
|
|
707 mov xl, yl
|
|
|
708
|
|
|
709 .Lmul_returnx:
|
|
|
710 /* Set the sign bit and return. */
|
|
|
711 extui a7, a7, 31, 1
|
|
|
712 slli xh, xh, 1
|
|
|
713 ssai 1
|
|
|
714 src xh, a7, xh
|
|
|
715 j .Lmul_done
|
|
|
716
|
|
|
717 .Lmul_ynan_or_inf:
|
|
|
718 /* If x is zero, return NaN. */
|
|
|
719 bnez xl, .Lmul_returny
|
|
|
720 slli a8, xh, 1
|
|
|
721 bnez a8, .Lmul_returny
|
|
|
722 movi a7, 0x80000 /* make it a quiet NaN */
|
|
|
723 or xh, yh, a7
|
|
|
724 j .Lmul_done
|
|
|
725
|
|
|
726 .align 4
|
|
|
727 .global __muldf3
|
|
|
728 .type __muldf3, @function
|
|
|
729 __muldf3:
|
|
|
730 #if __XTENSA_CALL0_ABI__
|
|
|
731 leaf_entry sp, 32
|
|
|
732 addi sp, sp, -32
|
|
|
733 s32i a12, sp, 16
|
|
|
734 s32i a13, sp, 20
|
|
|
735 s32i a14, sp, 24
|
|
|
736 s32i a15, sp, 28
|
|
|
737 #elif XCHAL_NO_MUL
|
|
|
738 /* This is not really a leaf function; allocate enough stack space
|
|
|
739 to allow CALL12s to a helper function. */
|
|
|
740 leaf_entry sp, 64
|
|
|
741 #else
|
|
|
742 leaf_entry sp, 32
|
|
|
743 #endif
|
|
|
744 movi a6, 0x7ff00000
|
|
|
745
|
|
|
746 /* Get the sign of the result. */
|
|
|
747 xor a7, xh, yh
|
|
|
748
|
|
|
749 /* Check for NaN and infinity. */
|
|
|
750 ball xh, a6, .Lmul_xnan_or_inf
|
|
|
751 ball yh, a6, .Lmul_ynan_or_inf
|
|
|
752
|
|
|
753 /* Extract the exponents. */
|
|
|
754 extui a8, xh, 20, 11
|
|
|
755 extui a9, yh, 20, 11
|
|
|
756
|
|
|
757 beqz a8, .Lmul_xexpzero
|
|
|
758 .Lmul_xnormalized:
|
|
|
759 beqz a9, .Lmul_yexpzero
|
|
|
760 .Lmul_ynormalized:
|
|
|
761
|
|
|
762 /* Add the exponents. */
|
|
|
763 add a8, a8, a9
|
|
|
764
|
|
|
765 /* Replace sign/exponent fields with explicit "1.0". */
|
|
|
766 movi a10, 0x1fffff
|
|
|
767 or xh, xh, a6
|
|
|
768 and xh, xh, a10
|
|
|
769 or yh, yh, a6
|
|
|
770 and yh, yh, a10
|
|
|
771
|
|
|
772 /* Multiply 64x64 to 128 bits. The result ends up in xh/xl/a6.
|
|
|
773 The least-significant word of the result is thrown away except
|
|
|
774 that if it is nonzero, the lsb of a6 is set to 1. */
|
|
|
775 #if XCHAL_HAVE_MUL32_HIGH
|
|
|
776
|
|
|
777 /* Compute a6 with any carry-outs in a10. */
|
|
|
778 movi a10, 0
|
|
|
779 mull a6, xl, yh
|
|
|
780 mull a11, xh, yl
|
|
|
781 add a6, a6, a11
|
|
|
782 bgeu a6, a11, 1f
|
|
|
783 addi a10, a10, 1
|
|
|
784 1:
|
|
|
785 muluh a11, xl, yl
|
|
|
786 add a6, a6, a11
|
|
|
787 bgeu a6, a11, 1f
|
|
|
788 addi a10, a10, 1
|
|
|
789 1:
|
|
|
790 /* If the low word of the result is nonzero, set the lsb of a6. */
|
|
|
791 mull a11, xl, yl
|
|
|
792 beqz a11, 1f
|
|
|
793 movi a9, 1
|
|
|
794 or a6, a6, a9
|
|
|
795 1:
|
|
|
796 /* Compute xl with any carry-outs in a9. */
|
|
|
797 movi a9, 0
|
|
|
798 mull a11, xh, yh
|
|
|
799 add a10, a10, a11
|
|
|
800 bgeu a10, a11, 1f
|
|
|
801 addi a9, a9, 1
|
|
|
802 1:
|
|
|
803 muluh a11, xh, yl
|
|
|
804 add a10, a10, a11
|
|
|
805 bgeu a10, a11, 1f
|
|
|
806 addi a9, a9, 1
|
|
|
807 1:
|
|
|
808 muluh xl, xl, yh
|
|
|
809 add xl, xl, a10
|
|
|
810 bgeu xl, a10, 1f
|
|
|
811 addi a9, a9, 1
|
|
|
812 1:
|
|
|
813 /* Compute xh. */
|
|
|
814 muluh xh, xh, yh
|
|
|
815 add xh, xh, a9
|
|
|
816
|
|
|
817 #else /* ! XCHAL_HAVE_MUL32_HIGH */
|
|
|
818
|
|
|
819 /* Break the inputs into 16-bit chunks and compute 16 32-bit partial
|
|
|
820 products. These partial products are:
|
|
|
821
|
|
|
822 0 xll * yll
|
|
|
823
|
|
|
824 1 xll * ylh
|
|
|
825 2 xlh * yll
|
|
|
826
|
|
|
827 3 xll * yhl
|
|
|
828 4 xlh * ylh
|
|
|
829 5 xhl * yll
|
|
|
830
|
|
|
831 6 xll * yhh
|
|
|
832 7 xlh * yhl
|
|
|
833 8 xhl * ylh
|
|
|
834 9 xhh * yll
|
|
|
835
|
|
|
836 10 xlh * yhh
|
|
|
837 11 xhl * yhl
|
|
|
838 12 xhh * ylh
|
|
|
839
|
|
|
840 13 xhl * yhh
|
|
|
841 14 xhh * yhl
|
|
|
842
|
|
|
843 15 xhh * yhh
|
|
|
844
|
|
|
845 where the input chunks are (hh, hl, lh, ll). If using the Mul16
|
|
|
846 or Mul32 multiplier options, these input chunks must be stored in
|
|
|
847 separate registers. For Mac16, the UMUL.AA.* opcodes can specify
|
|
|
848 that the inputs come from either half of the registers, so there
|
|
|
849 is no need to shift them out ahead of time. If there is no
|
|
|
850 multiply hardware, the 16-bit chunks can be extracted when setting
|
|
|
851 up the arguments to the separate multiply function. */
|
|
|
852
|
|
|
853 /* Save a7 since it is needed to hold a temporary value. */
|
|
|
854 s32i a7, sp, 4
|
|
|
855 #if __XTENSA_CALL0_ABI__ && XCHAL_NO_MUL
|
|
|
856 /* Calling a separate multiply function will clobber a0 and requires
|
|
|
857 use of a8 as a temporary, so save those values now. (The function
|
|
|
858 uses a custom ABI so nothing else needs to be saved.) */
|
|
|
859 s32i a0, sp, 0
|
|
|
860 s32i a8, sp, 8
|
|
|
861 #endif
|
|
|
862
|
|
|
863 #if XCHAL_HAVE_MUL16 || XCHAL_HAVE_MUL32
|
|
|
864
|
|
|
865 #define xlh a12
|
|
|
866 #define ylh a13
|
|
|
867 #define xhh a14
|
|
|
868 #define yhh a15
|
|
|
869
|
|
|
870 /* Get the high halves of the inputs into registers. */
|
|
|
871 srli xlh, xl, 16
|
|
|
872 srli ylh, yl, 16
|
|
|
873 srli xhh, xh, 16
|
|
|
874 srli yhh, yh, 16
|
|
|
875
|
|
|
876 #define xll xl
|
|
|
877 #define yll yl
|
|
|
878 #define xhl xh
|
|
|
879 #define yhl yh
|
|
|
880
|
|
|
881 #if XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MUL16
|
|
|
882 /* Clear the high halves of the inputs. This does not matter
|
|
|
883 for MUL16 because the high bits are ignored. */
|
|
|
884 extui xl, xl, 0, 16
|
|
|
885 extui xh, xh, 0, 16
|
|
|
886 extui yl, yl, 0, 16
|
|
|
887 extui yh, yh, 0, 16
|
|
|
888 #endif
|
|
|
889 #endif /* MUL16 || MUL32 */
|
|
|
890
|
|
|
891
|
|
|
892 #if XCHAL_HAVE_MUL16
|
|
|
893
|
|
|
894 #define do_mul(dst, xreg, xhalf, yreg, yhalf) \
|
|
|
895 mul16u dst, xreg ## xhalf, yreg ## yhalf
|
|
|
896
|
|
|
897 #elif XCHAL_HAVE_MUL32
|
|
|
898
|
|
|
899 #define do_mul(dst, xreg, xhalf, yreg, yhalf) \
|
|
|
900 mull dst, xreg ## xhalf, yreg ## yhalf
|
|
|
901
|
|
|
902 #elif XCHAL_HAVE_MAC16
|
|
|
903
|
|
|
904 /* The preprocessor insists on inserting a space when concatenating after
|
|
|
905 a period in the definition of do_mul below. These macros are a workaround
|
|
|
906 using underscores instead of periods when doing the concatenation. */
|
|
|
907 #define umul_aa_ll umul.aa.ll
|
|
|
908 #define umul_aa_lh umul.aa.lh
|
|
|
909 #define umul_aa_hl umul.aa.hl
|
|
|
910 #define umul_aa_hh umul.aa.hh
|
|
|
911
|
|
|
912 #define do_mul(dst, xreg, xhalf, yreg, yhalf) \
|
|
|
913 umul_aa_ ## xhalf ## yhalf xreg, yreg; \
|
|
|
914 rsr dst, ACCLO
|
|
|
915
|
|
|
916 #else /* no multiply hardware */
|
|
|
917
|
|
|
918 #define set_arg_l(dst, src) \
|
|
|
919 extui dst, src, 0, 16
|
|
|
920 #define set_arg_h(dst, src) \
|
|
|
921 srli dst, src, 16
|
|
|
922
|
|
|
923 #if __XTENSA_CALL0_ABI__
|
|
|
924 #define do_mul(dst, xreg, xhalf, yreg, yhalf) \
|
|
|
925 set_arg_ ## xhalf (a13, xreg); \
|
|
|
926 set_arg_ ## yhalf (a14, yreg); \
|
|
|
927 call0 .Lmul_mulsi3; \
|
|
|
928 mov dst, a12
|
|
|
929 #else
|
|
|
930 #define do_mul(dst, xreg, xhalf, yreg, yhalf) \
|
|
|
931 set_arg_ ## xhalf (a14, xreg); \
|
|
|
932 set_arg_ ## yhalf (a15, yreg); \
|
|
|
933 call12 .Lmul_mulsi3; \
|
|
|
934 mov dst, a14
|
|
|
935 #endif /* __XTENSA_CALL0_ABI__ */
|
|
|
936
|
|
|
937 #endif /* no multiply hardware */
|
|
|
938
|
|
|
939 /* Add pp1 and pp2 into a10 with carry-out in a9. */
|
|
|
940 do_mul(a10, xl, l, yl, h) /* pp 1 */
|
|
|
941 do_mul(a11, xl, h, yl, l) /* pp 2 */
|
|
|
942 movi a9, 0
|
|
|
943 add a10, a10, a11
|
|
|
944 bgeu a10, a11, 1f
|
|
|
945 addi a9, a9, 1
|
|
|
946 1:
|
|
|
947 /* Initialize a6 with a9/a10 shifted into position. Note that
|
|
|
948 this value can be safely incremented without any carry-outs. */
|
|
|
949 ssai 16
|
|
|
950 src a6, a9, a10
|
|
|
951
|
|
|
952 /* Compute the low word into a10. */
|
|
|
953 do_mul(a11, xl, l, yl, l) /* pp 0 */
|
|
|
954 sll a10, a10
|
|
|
955 add a10, a10, a11
|
|
|
956 bgeu a10, a11, 1f
|
|
|
957 addi a6, a6, 1
|
|
|
958 1:
|
|
|
959 /* Compute the contributions of pp0-5 to a6, with carry-outs in a9.
|
|
|
960 This is good enough to determine the low half of a6, so that any
|
|
|
961 nonzero bits from the low word of the result can be collapsed
|
|
|
962 into a6, freeing up a register. */
|
|
|
963 movi a9, 0
|
|
|
964 do_mul(a11, xl, l, yh, l) /* pp 3 */
|
|
|
965 add a6, a6, a11
|
|
|
966 bgeu a6, a11, 1f
|
|
|
967 addi a9, a9, 1
|
|
|
968 1:
|
|
|
969 do_mul(a11, xl, h, yl, h) /* pp 4 */
|
|
|
970 add a6, a6, a11
|
|
|
971 bgeu a6, a11, 1f
|
|
|
972 addi a9, a9, 1
|
|
|
973 1:
|
|
|
974 do_mul(a11, xh, l, yl, l) /* pp 5 */
|
|
|
975 add a6, a6, a11
|
|
|
976 bgeu a6, a11, 1f
|
|
|
977 addi a9, a9, 1
|
|
|
978 1:
|
|
|
979 /* Collapse any nonzero bits from the low word into a6. */
|
|
|
980 beqz a10, 1f
|
|
|
981 movi a11, 1
|
|
|
982 or a6, a6, a11
|
|
|
983 1:
|
|
|
984 /* Add pp6-9 into a11 with carry-outs in a10. */
|
|
|
985 do_mul(a7, xl, l, yh, h) /* pp 6 */
|
|
|
986 do_mul(a11, xh, h, yl, l) /* pp 9 */
|
|
|
987 movi a10, 0
|
|
|
988 add a11, a11, a7
|
|
|
989 bgeu a11, a7, 1f
|
|
|
990 addi a10, a10, 1
|
|
|
991 1:
|
|
|
992 do_mul(a7, xl, h, yh, l) /* pp 7 */
|
|
|
993 add a11, a11, a7
|
|
|
994 bgeu a11, a7, 1f
|
|
|
995 addi a10, a10, 1
|
|
|
996 1:
|
|
|
997 do_mul(a7, xh, l, yl, h) /* pp 8 */
|
|
|
998 add a11, a11, a7
|
|
|
999 bgeu a11, a7, 1f
|
|
|
1000 addi a10, a10, 1
|
|
|
1001 1:
|
|
|
1002 /* Shift a10/a11 into position, and add low half of a11 to a6. */
|
|
|
1003 src a10, a10, a11
|
|
|
1004 add a10, a10, a9
|
|
|
1005 sll a11, a11
|
|
|
1006 add a6, a6, a11
|
|
|
1007 bgeu a6, a11, 1f
|
|
|
1008 addi a10, a10, 1
|
|
|
1009 1:
|
|
|
1010 /* Add pp10-12 into xl with carry-outs in a9. */
|
|
|
1011 movi a9, 0
|
|
|
1012 do_mul(xl, xl, h, yh, h) /* pp 10 */
|
|
|
1013 add xl, xl, a10
|
|
|
1014 bgeu xl, a10, 1f
|
|
|
1015 addi a9, a9, 1
|
|
|
1016 1:
|
|
|
1017 do_mul(a10, xh, l, yh, l) /* pp 11 */
|
|
|
1018 add xl, xl, a10
|
|
|
1019 bgeu xl, a10, 1f
|
|
|
1020 addi a9, a9, 1
|
|
|
1021 1:
|
|
|
1022 do_mul(a10, xh, h, yl, h) /* pp 12 */
|
|
|
1023 add xl, xl, a10
|
|
|
1024 bgeu xl, a10, 1f
|
|
|
1025 addi a9, a9, 1
|
|
|
1026 1:
|
|
|
1027 /* Add pp13-14 into a11 with carry-outs in a10. */
|
|
|
1028 do_mul(a11, xh, l, yh, h) /* pp 13 */
|
|
|
1029 do_mul(a7, xh, h, yh, l) /* pp 14 */
|
|
|
1030 movi a10, 0
|
|
|
1031 add a11, a11, a7
|
|
|
1032 bgeu a11, a7, 1f
|
|
|
1033 addi a10, a10, 1
|
|
|
1034 1:
|
|
|
1035 /* Shift a10/a11 into position, and add low half of a11 to a6. */
|
|
|
1036 src a10, a10, a11
|
|
|
1037 add a10, a10, a9
|
|
|
1038 sll a11, a11
|
|
|
1039 add xl, xl, a11
|
|
|
1040 bgeu xl, a11, 1f
|
|
|
1041 addi a10, a10, 1
|
|
|
1042 1:
|
|
|
1043 /* Compute xh. */
|
|
|
1044 do_mul(xh, xh, h, yh, h) /* pp 15 */
|
|
|
1045 add xh, xh, a10
|
|
|
1046
|
|
|
1047 /* Restore values saved on the stack during the multiplication. */
|
|
|
1048 l32i a7, sp, 4
|
|
|
1049 #if __XTENSA_CALL0_ABI__ && XCHAL_NO_MUL
|
|
|
1050 l32i a0, sp, 0
|
|
|
1051 l32i a8, sp, 8
|
|
|
1052 #endif
|
|
|
1053 #endif /* ! XCHAL_HAVE_MUL32_HIGH */
|
|
|
1054
|
|
|
1055 /* Shift left by 12 bits, unless there was a carry-out from the
|
|
|
1056 multiply, in which case, shift by 11 bits and increment the
|
|
|
1057 exponent. Note: It is convenient to use the constant 0x3ff
|
|
|
1058 instead of 0x400 when removing the extra exponent bias (so that
|
|
|
1059 it is easy to construct 0x7fe for the overflow check). Reverse
|
|
|
1060 the logic here to decrement the exponent sum by one unless there
|
|
|
1061 was a carry-out. */
|
|
|
1062 movi a4, 11
|
|
|
1063 srli a5, xh, 21 - 12
|
|
|
1064 bnez a5, 1f
|
|
|
1065 addi a4, a4, 1
|
|
|
1066 addi a8, a8, -1
|
|
|
1067 1: ssl a4
|
|
|
1068 src xh, xh, xl
|
|
|
1069 src xl, xl, a6
|
|
|
1070 sll a6, a6
|
|
|
1071
|
|
|
1072 /* Subtract the extra bias from the exponent sum (plus one to account
|
|
|
1073 for the explicit "1.0" of the mantissa that will be added to the
|
|
|
1074 exponent in the final result). */
|
|
|
1075 movi a4, 0x3ff
|
|
|
1076 sub a8, a8, a4
|
|
|
1077
|
|
|
1078 /* Check for over/underflow. The value in a8 is one less than the
|
|
|
1079 final exponent, so values in the range 0..7fd are OK here. */
|
|
|
1080 slli a4, a4, 1 /* 0x7fe */
|
|
|
1081 bgeu a8, a4, .Lmul_overflow
|
|
|
1082
|
|
|
1083 .Lmul_round:
|
|
|
1084 /* Round. */
|
|
|
1085 bgez a6, .Lmul_rounded
|
|
|
1086 addi xl, xl, 1
|
|
|
1087 beqz xl, .Lmul_roundcarry
|
|
|
1088 slli a6, a6, 1
|
|
|
1089 beqz a6, .Lmul_exactlyhalf
|
|
|
1090
|
|
|
1091 .Lmul_rounded:
|
|
|
1092 /* Add the exponent to the mantissa. */
|
|
|
1093 slli a8, a8, 20
|
|
|
1094 add xh, xh, a8
|
|
|
1095
|
|
|
1096 .Lmul_addsign:
|
|
|
1097 /* Add the sign bit. */
|
|
|
1098 srli a7, a7, 31
|
|
|
1099 slli a7, a7, 31
|
|
|
1100 or xh, xh, a7
|
|
|
1101
|
|
|
1102 .Lmul_done:
|
|
|
1103 #if __XTENSA_CALL0_ABI__
|
|
|
1104 l32i a12, sp, 16
|
|
|
1105 l32i a13, sp, 20
|
|
|
1106 l32i a14, sp, 24
|
|
|
1107 l32i a15, sp, 28
|
|
|
1108 addi sp, sp, 32
|
|
|
1109 #endif
|
|
|
1110 leaf_return
|
|
|
1111
|
|
|
1112 .Lmul_exactlyhalf:
|
|
|
1113 /* Round down to the nearest even value. */
|
|
|
1114 srli xl, xl, 1
|
|
|
1115 slli xl, xl, 1
|
|
|
1116 j .Lmul_rounded
|
|
|
1117
|
|
|
1118 .Lmul_roundcarry:
|
|
|
1119 /* xl is always zero when the rounding increment overflows, so
|
|
|
1120 there's no need to round it to an even value. */
|
|
|
1121 addi xh, xh, 1
|
|
|
1122 /* Overflow is OK -- it will be added to the exponent. */
|
|
|
1123 j .Lmul_rounded
|
|
|
1124
|
|
|
1125 .Lmul_overflow:
|
|
|
1126 bltz a8, .Lmul_underflow
|
|
|
1127 /* Return +/- Infinity. */
|
|
|
1128 addi a8, a4, 1 /* 0x7ff */
|
|
|
1129 slli xh, a8, 20
|
|
|
1130 movi xl, 0
|
|
|
1131 j .Lmul_addsign
|
|
|
1132
|
|
|
1133 .Lmul_underflow:
|
|
|
1134 /* Create a subnormal value, where the exponent field contains zero,
|
|
|
1135 but the effective exponent is 1. The value of a8 is one less than
|
|
|
1136 the actual exponent, so just negate it to get the shift amount. */
|
|
|
1137 neg a8, a8
|
|
|
1138 mov a9, a6
|
|
|
1139 ssr a8
|
|
|
1140 bgeui a8, 32, .Lmul_bigshift
|
|
|
1141
|
|
|
1142 /* Shift xh/xl right. Any bits that are shifted out of xl are saved
|
|
|
1143 in a6 (combined with the shifted-out bits currently in a6) for
|
|
|
1144 rounding the result. */
|
|
|
1145 sll a6, xl
|
|
|
1146 src xl, xh, xl
|
|
|
1147 srl xh, xh
|
|
|
1148 j 1f
|
|
|
1149
|
|
|
1150 .Lmul_bigshift:
|
|
|
1151 bgeui a8, 64, .Lmul_flush_to_zero
|
|
|
1152 sll a10, xl /* lost bits shifted out of xl */
|
|
|
1153 src a6, xh, xl
|
|
|
1154 srl xl, xh
|
|
|
1155 movi xh, 0
|
|
|
1156 or a9, a9, a10
|
|
|
1157
|
|
|
1158 /* Set the exponent to zero. */
|
|
|
1159 1: movi a8, 0
|
|
|
1160
|
|
|
1161 /* Pack any nonzero bits shifted out into a6. */
|
|
|
1162 beqz a9, .Lmul_round
|
|
|
1163 movi a9, 1
|
|
|
1164 or a6, a6, a9
|
|
|
1165 j .Lmul_round
|
|
|
1166
|
|
|
1167 .Lmul_flush_to_zero:
|
|
|
1168 /* Return zero with the appropriate sign bit. */
|
|
|
1169 srli xh, a7, 31
|
|
|
1170 slli xh, xh, 31
|
|
|
1171 movi xl, 0
|
|
|
1172 j .Lmul_done
|
|
|
1173
|
|
|
1174 #if XCHAL_NO_MUL
|
|
|
1175
|
|
|
1176 /* For Xtensa processors with no multiply hardware, this simplified
|
|
|
1177 version of _mulsi3 is used for multiplying 16-bit chunks of
|
|
|
1178 the floating-point mantissas. When using CALL0, this function
|
|
|
1179 uses a custom ABI: the inputs are passed in a13 and a14, the
|
|
|
1180 result is returned in a12, and a8 and a15 are clobbered. */
|
|
|
1181 .align 4
|
|
|
1182 .Lmul_mulsi3:
|
|
|
1183 leaf_entry sp, 16
|
|
|
1184 .macro mul_mulsi3_body dst, src1, src2, tmp1, tmp2
|
|
|
1185 movi \dst, 0
|
|
|
1186 1: add \tmp1, \src2, \dst
|
|
|
1187 extui \tmp2, \src1, 0, 1
|
|
|
1188 movnez \dst, \tmp1, \tmp2
|
|
|
1189
|
|
|
1190 do_addx2 \tmp1, \src2, \dst, \tmp1
|
|
|
1191 extui \tmp2, \src1, 1, 1
|
|
|
1192 movnez \dst, \tmp1, \tmp2
|
|
|
1193
|
|
|
1194 do_addx4 \tmp1, \src2, \dst, \tmp1
|
|
|
1195 extui \tmp2, \src1, 2, 1
|
|
|
1196 movnez \dst, \tmp1, \tmp2
|
|
|
1197
|
|
|
1198 do_addx8 \tmp1, \src2, \dst, \tmp1
|
|
|
1199 extui \tmp2, \src1, 3, 1
|
|
|
1200 movnez \dst, \tmp1, \tmp2
|
|
|
1201
|
|
|
1202 srli \src1, \src1, 4
|
|
|
1203 slli \src2, \src2, 4
|
|
|
1204 bnez \src1, 1b
|
|
|
1205 .endm
|
|
|
1206 #if __XTENSA_CALL0_ABI__
|
|
|
1207 mul_mulsi3_body a12, a13, a14, a15, a8
|
|
|
1208 #else
|
|
|
1209 /* The result will be written into a2, so save that argument in a4. */
|
|
|
1210 mov a4, a2
|
|
|
1211 mul_mulsi3_body a2, a4, a3, a5, a6
|
|
|
1212 #endif
|
|
|
1213 leaf_return
|
|
|
1214 #endif /* XCHAL_NO_MUL */
|
|
|
1215 #endif /* L_muldf3 */
|
|
|
1216
|
|
|
1217 #ifdef L_divdf3
|
|
|
1218
|
|
|
1219 /* Division */
|
|
|
1220 __divdf3_aux:
|
|
|
1221
|
|
|
1222 /* Handle unusual cases (zeros, subnormals, NaNs and Infinities).
|
|
|
1223 (This code is placed before the start of the function just to
|
|
|
1224 keep it in range of the limited branch displacements.) */
|
|
|
1225
|
|
|
1226 .Ldiv_yexpzero:
|
|
|
1227 /* Clear the sign bit of y. */
|
|
|
1228 slli yh, yh, 1
|
|
|
1229 srli yh, yh, 1
|
|
|
1230
|
|
|
1231 /* Check for division by zero. */
|
|
|
1232 or a10, yh, yl
|
|
|
1233 beqz a10, .Ldiv_yzero
|
|
|
1234
|
|
|
1235 /* Normalize y. Adjust the exponent in a9. */
|
|
|
1236 beqz yh, .Ldiv_yh_zero
|
|
|
1237 do_nsau a10, yh, a11, a9
|
|
|
1238 addi a10, a10, -11
|
|
|
1239 ssl a10
|
|
|
1240 src yh, yh, yl
|
|
|
1241 sll yl, yl
|
|
|
1242 movi a9, 1
|
|
|
1243 sub a9, a9, a10
|
|
|
1244 j .Ldiv_ynormalized
|
|
|
1245 .Ldiv_yh_zero:
|
|
|
1246 do_nsau a10, yl, a11, a9
|
|
|
1247 addi a10, a10, -11
|
|
|
1248 movi a9, -31
|
|
|
1249 sub a9, a9, a10
|
|
|
1250 ssl a10
|
|
|
1251 bltz a10, .Ldiv_yl_srl
|
|
|
1252 sll yh, yl
|
|
|
1253 movi yl, 0
|
|
|
1254 j .Ldiv_ynormalized
|
|
|
1255 .Ldiv_yl_srl:
|
|
|
1256 srl yh, yl
|
|
|
1257 sll yl, yl
|
|
|
1258 j .Ldiv_ynormalized
|
|
|
1259
|
|
|
1260 .Ldiv_yzero:
|
|
|
1261 /* y is zero. Return NaN if x is also zero; otherwise, infinity. */
|
|
|
1262 slli xh, xh, 1
|
|
|
1263 srli xh, xh, 1
|
|
|
1264 or xl, xl, xh
|
|
|
1265 srli xh, a7, 31
|
|
|
1266 slli xh, xh, 31
|
|
|
1267 or xh, xh, a6
|
|
|
1268 bnez xl, 1f
|
|
|
1269 movi a4, 0x80000 /* make it a quiet NaN */
|
|
|
1270 or xh, xh, a4
|
|
|
1271 1: movi xl, 0
|
|
|
1272 leaf_return
|
|
|
1273
|
|
|
1274 .Ldiv_xexpzero:
|
|
|
1275 /* Clear the sign bit of x. */
|
|
|
1276 slli xh, xh, 1
|
|
|
1277 srli xh, xh, 1
|
|
|
1278
|
|
|
1279 /* If x is zero, return zero. */
|
|
|
1280 or a10, xh, xl
|
|
|
1281 beqz a10, .Ldiv_return_zero
|
|
|
1282
|
|
|
1283 /* Normalize x. Adjust the exponent in a8. */
|
|
|
1284 beqz xh, .Ldiv_xh_zero
|
|
|
1285 do_nsau a10, xh, a11, a8
|
|
|
1286 addi a10, a10, -11
|
|
|
1287 ssl a10
|
|
|
1288 src xh, xh, xl
|
|
|
1289 sll xl, xl
|
|
|
1290 movi a8, 1
|
|
|
1291 sub a8, a8, a10
|
|
|
1292 j .Ldiv_xnormalized
|
|
|
1293 .Ldiv_xh_zero:
|
|
|
1294 do_nsau a10, xl, a11, a8
|
|
|
1295 addi a10, a10, -11
|
|
|
1296 movi a8, -31
|
|
|
1297 sub a8, a8, a10
|
|
|
1298 ssl a10
|
|
|
1299 bltz a10, .Ldiv_xl_srl
|
|
|
1300 sll xh, xl
|
|
|
1301 movi xl, 0
|
|
|
1302 j .Ldiv_xnormalized
|
|
|
1303 .Ldiv_xl_srl:
|
|
|
1304 srl xh, xl
|
|
|
1305 sll xl, xl
|
|
|
1306 j .Ldiv_xnormalized
|
|
|
1307
|
|
|
1308 .Ldiv_return_zero:
|
|
|
1309 /* Return zero with the appropriate sign bit. */
|
|
|
1310 srli xh, a7, 31
|
|
|
1311 slli xh, xh, 31
|
|
|
1312 movi xl, 0
|
|
|
1313 leaf_return
|
|
|
1314
|
|
|
1315 .Ldiv_xnan_or_inf:
|
|
|
1316 /* Set the sign bit of the result. */
|
|
|
1317 srli a7, yh, 31
|
|
|
1318 slli a7, a7, 31
|
|
|
1319 xor xh, xh, a7
|
|
|
1320 /* If y is NaN or Inf, return NaN. */
|
|
|
1321 bnall yh, a6, 1f
|
|
|
1322 movi a4, 0x80000 /* make it a quiet NaN */
|
|
|
1323 or xh, xh, a4
|
|
|
1324 1: leaf_return
|
|
|
1325
|
|
|
1326 .Ldiv_ynan_or_inf:
|
|
|
1327 /* If y is Infinity, return zero. */
|
|
|
1328 slli a8, yh, 12
|
|
|
1329 or a8, a8, yl
|
|
|
1330 beqz a8, .Ldiv_return_zero
|
|
|
1331 /* y is NaN; return it. */
|
|
|
1332 mov xh, yh
|
|
|
1333 mov xl, yl
|
|
|
1334 leaf_return
|
|
|
1335
|
|
|
1336 .Ldiv_highequal1:
|
|
|
1337 bltu xl, yl, 2f
|
|
|
1338 j 3f
|
|
|
1339
|
|
|
1340 .align 4
|
|
|
1341 .global __divdf3
|
|
|
1342 .type __divdf3, @function
|
|
|
1343 __divdf3:
|
|
|
1344 leaf_entry sp, 16
|
|
|
1345 movi a6, 0x7ff00000
|
|
|
1346
|
|
|
1347 /* Get the sign of the result. */
|
|
|
1348 xor a7, xh, yh
|
|
|
1349
|
|
|
1350 /* Check for NaN and infinity. */
|
|
|
1351 ball xh, a6, .Ldiv_xnan_or_inf
|
|
|
1352 ball yh, a6, .Ldiv_ynan_or_inf
|
|
|
1353
|
|
|
1354 /* Extract the exponents. */
|
|
|
1355 extui a8, xh, 20, 11
|
|
|
1356 extui a9, yh, 20, 11
|
|
|
1357
|
|
|
1358 beqz a9, .Ldiv_yexpzero
|
|
|
1359 .Ldiv_ynormalized:
|
|
|
1360 beqz a8, .Ldiv_xexpzero
|
|
|
1361 .Ldiv_xnormalized:
|
|
|
1362
|
|
|
1363 /* Subtract the exponents. */
|
|
|
1364 sub a8, a8, a9
|
|
|
1365
|
|
|
1366 /* Replace sign/exponent fields with explicit "1.0". */
|
|
|
1367 movi a10, 0x1fffff
|
|
|
1368 or xh, xh, a6
|
|
|
1369 and xh, xh, a10
|
|
|
1370 or yh, yh, a6
|
|
|
1371 and yh, yh, a10
|
|
|
1372
|
|
|
1373 /* Set SAR for left shift by one. */
|
|
|
1374 ssai (32 - 1)
|
|
|
1375
|
|
|
1376 /* The first digit of the mantissa division must be a one.
|
|
|
1377 Shift x (and adjust the exponent) as needed to make this true. */
|
|
|
1378 bltu yh, xh, 3f
|
|
|
1379 beq yh, xh, .Ldiv_highequal1
|
|
|
1380 2: src xh, xh, xl
|
|
|
1381 sll xl, xl
|
|
|
1382 addi a8, a8, -1
|
|
|
1383 3:
|
|
|
1384 /* Do the first subtraction and shift. */
|
|
|
1385 sub xh, xh, yh
|
|
|
1386 bgeu xl, yl, 1f
|
|
|
1387 addi xh, xh, -1
|
|
|
1388 1: sub xl, xl, yl
|
|
|
1389 src xh, xh, xl
|
|
|
1390 sll xl, xl
|
|
|
1391
|
|
|
1392 /* Put the quotient into a10/a11. */
|
|
|
1393 movi a10, 0
|
|
|
1394 movi a11, 1
|
|
|
1395
|
|
|
1396 /* Divide one bit at a time for 52 bits. */
|
|
|
1397 movi a9, 52
|
|
|
1398 #if XCHAL_HAVE_LOOPS
|
|
|
1399 loop a9, .Ldiv_loopend
|
|
|
1400 #endif
|
|
|
1401 .Ldiv_loop:
|
|
|
1402 /* Shift the quotient << 1. */
|
|
|
1403 src a10, a10, a11
|
|
|
1404 sll a11, a11
|
|
|
1405
|
|
|
1406 /* Is this digit a 0 or 1? */
|
|
|
1407 bltu xh, yh, 3f
|
|
|
1408 beq xh, yh, .Ldiv_highequal2
|
|
|
1409
|
|
|
1410 /* Output a 1 and subtract. */
|
|
|
1411 2: addi a11, a11, 1
|
|
|
1412 sub xh, xh, yh
|
|
|
1413 bgeu xl, yl, 1f
|
|
|
1414 addi xh, xh, -1
|
|
|
1415 1: sub xl, xl, yl
|
|
|
1416
|
|
|
1417 /* Shift the dividend << 1. */
|
|
|
1418 3: src xh, xh, xl
|
|
|
1419 sll xl, xl
|
|
|
1420
|
|
|
1421 #if !XCHAL_HAVE_LOOPS
|
|
|
1422 addi a9, a9, -1
|
|
|
1423 bnez a9, .Ldiv_loop
|
|
|
1424 #endif
|
|
|
1425 .Ldiv_loopend:
|
|
|
1426
|
|
|
1427 /* Add the exponent bias (less one to account for the explicit "1.0"
|
|
|
1428 of the mantissa that will be added to the exponent in the final
|
|
|
1429 result). */
|
|
|
1430 movi a9, 0x3fe
|
|
|
1431 add a8, a8, a9
|
|
|
1432
|
|
|
1433 /* Check for over/underflow. The value in a8 is one less than the
|
|
|
1434 final exponent, so values in the range 0..7fd are OK here. */
|
|
|
1435 addmi a9, a9, 0x400 /* 0x7fe */
|
|
|
1436 bgeu a8, a9, .Ldiv_overflow
|
|
|
1437
|
|
|
1438 .Ldiv_round:
|
|
|
1439 /* Round. The remainder (<< 1) is in xh/xl. */
|
|
|
1440 bltu xh, yh, .Ldiv_rounded
|
|
|
1441 beq xh, yh, .Ldiv_highequal3
|
|
|
1442 .Ldiv_roundup:
|
|
|
1443 addi a11, a11, 1
|
|
|
1444 beqz a11, .Ldiv_roundcarry
|
|
|
1445
|
|
|
1446 .Ldiv_rounded:
|
|
|
1447 mov xl, a11
|
|
|
1448 /* Add the exponent to the mantissa. */
|
|
|
1449 slli a8, a8, 20
|
|
|
1450 add xh, a10, a8
|
|
|
1451
|
|
|
1452 .Ldiv_addsign:
|
|
|
1453 /* Add the sign bit. */
|
|
|
1454 srli a7, a7, 31
|
|
|
1455 slli a7, a7, 31
|
|
|
1456 or xh, xh, a7
|
|
|
1457 leaf_return
|
|
|
1458
|
|
|
1459 .Ldiv_highequal2:
|
|
|
1460 bgeu xl, yl, 2b
|
|
|
1461 j 3b
|
|
|
1462
|
|
|
1463 .Ldiv_highequal3:
|
|
|
1464 bltu xl, yl, .Ldiv_rounded
|
|
|
1465 bne xl, yl, .Ldiv_roundup
|
|
|
1466
|
|
|
1467 /* Remainder is exactly half the divisor. Round even. */
|
|
|
1468 addi a11, a11, 1
|
|
|
1469 beqz a11, .Ldiv_roundcarry
|
|
|
1470 srli a11, a11, 1
|
|
|
1471 slli a11, a11, 1
|
|
|
1472 j .Ldiv_rounded
|
|
|
1473
|
|
|
1474 .Ldiv_overflow:
|
|
|
1475 bltz a8, .Ldiv_underflow
|
|
|
1476 /* Return +/- Infinity. */
|
|
|
1477 addi a8, a9, 1 /* 0x7ff */
|
|
|
1478 slli xh, a8, 20
|
|
|
1479 movi xl, 0
|
|
|
1480 j .Ldiv_addsign
|
|
|
1481
|
|
|
1482 .Ldiv_underflow:
|
|
|
1483 /* Create a subnormal value, where the exponent field contains zero,
|
|
|
1484 but the effective exponent is 1. The value of a8 is one less than
|
|
|
1485 the actual exponent, so just negate it to get the shift amount. */
|
|
|
1486 neg a8, a8
|
|
|
1487 ssr a8
|
|
|
1488 bgeui a8, 32, .Ldiv_bigshift
|
|
|
1489
|
|
|
1490 /* Shift a10/a11 right. Any bits that are shifted out of a11 are
|
|
|
1491 saved in a6 for rounding the result. */
|
|
|
1492 sll a6, a11
|
|
|
1493 src a11, a10, a11
|
|
|
1494 srl a10, a10
|
|
|
1495 j 1f
|
|
|
1496
|
|
|
1497 .Ldiv_bigshift:
|
|
|
1498 bgeui a8, 64, .Ldiv_flush_to_zero
|
|
|
1499 sll a9, a11 /* lost bits shifted out of a11 */
|
|
|
1500 src a6, a10, a11
|
|
|
1501 srl a11, a10
|
|
|
1502 movi a10, 0
|
|
|
1503 or xl, xl, a9
|
|
|
1504
|
|
|
1505 /* Set the exponent to zero. */
|
|
|
1506 1: movi a8, 0
|
|
|
1507
|
|
|
1508 /* Pack any nonzero remainder (in xh/xl) into a6. */
|
|
|
1509 or xh, xh, xl
|
|
|
1510 beqz xh, 1f
|
|
|
1511 movi a9, 1
|
|
|
1512 or a6, a6, a9
|
|
|
1513
|
|
|
1514 /* Round a10/a11 based on the bits shifted out into a6. */
|
|
|
1515 1: bgez a6, .Ldiv_rounded
|
|
|
1516 addi a11, a11, 1
|
|
|
1517 beqz a11, .Ldiv_roundcarry
|
|
|
1518 slli a6, a6, 1
|
|
|
1519 bnez a6, .Ldiv_rounded
|
|
|
1520 srli a11, a11, 1
|
|
|
1521 slli a11, a11, 1
|
|
|
1522 j .Ldiv_rounded
|
|
|
1523
|
|
|
1524 .Ldiv_roundcarry:
|
|
|
1525 /* a11 is always zero when the rounding increment overflows, so
|
|
|
1526 there's no need to round it to an even value. */
|
|
|
1527 addi a10, a10, 1
|
|
|
1528 /* Overflow to the exponent field is OK. */
|
|
|
1529 j .Ldiv_rounded
|
|
|
1530
|
|
|
1531 .Ldiv_flush_to_zero:
|
|
|
1532 /* Return zero with the appropriate sign bit. */
|
|
|
1533 srli xh, a7, 31
|
|
|
1534 slli xh, xh, 31
|
|
|
1535 movi xl, 0
|
|
|
1536 leaf_return
|
|
|
1537
|
|
|
1538 #endif /* L_divdf3 */
|
|
|
1539
|
|
|
1540 #ifdef L_cmpdf2
|
|
|
1541
|
|
|
1542 /* Equal and Not Equal */
|
|
|
1543
|
|
|
1544 .align 4
|
|
|
1545 .global __eqdf2
|
|
|
1546 .global __nedf2
|
|
|
1547 .set __nedf2, __eqdf2
|
|
|
1548 .type __eqdf2, @function
|
|
|
1549 __eqdf2:
|
|
|
1550 leaf_entry sp, 16
|
|
|
1551 bne xl, yl, 2f
|
|
|
1552 bne xh, yh, 4f
|
|
|
1553
|
|
|
1554 /* The values are equal but NaN != NaN. Check the exponent. */
|
|
|
1555 movi a6, 0x7ff00000
|
|
|
1556 ball xh, a6, 3f
|
|
|
1557
|
|
|
1558 /* Equal. */
|
|
|
1559 movi a2, 0
|
|
|
1560 leaf_return
|
|
|
1561
|
|
|
1562 /* Not equal. */
|
|
|
1563 2: movi a2, 1
|
|
|
1564 leaf_return
|
|
|
1565
|
|
|
1566 /* Check if the mantissas are nonzero. */
|
|
|
1567 3: slli a7, xh, 12
|
|
|
1568 or a7, a7, xl
|
|
|
1569 j 5f
|
|
|
1570
|
|
|
1571 /* Check if x and y are zero with different signs. */
|
|
|
1572 4: or a7, xh, yh
|
|
|
1573 slli a7, a7, 1
|
|
|
1574 or a7, a7, xl /* xl == yl here */
|
|
|
1575
|
|
|
1576 /* Equal if a7 == 0, where a7 is either abs(x | y) or the mantissa
|
|
|
1577 or x when exponent(x) = 0x7ff and x == y. */
|
|
|
1578 5: movi a2, 0
|
|
|
1579 movi a3, 1
|
|
|
1580 movnez a2, a3, a7
|
|
|
1581 leaf_return
|
|
|
1582
|
|
|
1583
|
|
|
1584 /* Greater Than */
|
|
|
1585
|
|
|
1586 .align 4
|
|
|
1587 .global __gtdf2
|
|
|
1588 .type __gtdf2, @function
|
|
|
1589 __gtdf2:
|
|
|
1590 leaf_entry sp, 16
|
|
|
1591 movi a6, 0x7ff00000
|
|
|
1592 ball xh, a6, 2f
|
|
|
1593 1: bnall yh, a6, .Lle_cmp
|
|
|
1594
|
|
|
1595 /* Check if y is a NaN. */
|
|
|
1596 slli a7, yh, 12
|
|
|
1597 or a7, a7, yl
|
|
|
1598 beqz a7, .Lle_cmp
|
|
|
1599 movi a2, 0
|
|
|
1600 leaf_return
|
|
|
1601
|
|
|
1602 /* Check if x is a NaN. */
|
|
|
1603 2: slli a7, xh, 12
|
|
|
1604 or a7, a7, xl
|
|
|
1605 beqz a7, 1b
|
|
|
1606 movi a2, 0
|
|
|
1607 leaf_return
|
|
|
1608
|
|
|
1609
|
|
|
1610 /* Less Than or Equal */
|
|
|
1611
|
|
|
1612 .align 4
|
|
|
1613 .global __ledf2
|
|
|
1614 .type __ledf2, @function
|
|
|
1615 __ledf2:
|
|
|
1616 leaf_entry sp, 16
|
|
|
1617 movi a6, 0x7ff00000
|
|
|
1618 ball xh, a6, 2f
|
|
|
1619 1: bnall yh, a6, .Lle_cmp
|
|
|
1620
|
|
|
1621 /* Check if y is a NaN. */
|
|
|
1622 slli a7, yh, 12
|
|
|
1623 or a7, a7, yl
|
|
|
1624 beqz a7, .Lle_cmp
|
|
|
1625 movi a2, 1
|
|
|
1626 leaf_return
|
|
|
1627
|
|
|
1628 /* Check if x is a NaN. */
|
|
|
1629 2: slli a7, xh, 12
|
|
|
1630 or a7, a7, xl
|
|
|
1631 beqz a7, 1b
|
|
|
1632 movi a2, 1
|
|
|
1633 leaf_return
|
|
|
1634
|
|
|
1635 .Lle_cmp:
|
|
|
1636 /* Check if x and y have different signs. */
|
|
|
1637 xor a7, xh, yh
|
|
|
1638 bltz a7, .Lle_diff_signs
|
|
|
1639
|
|
|
1640 /* Check if x is negative. */
|
|
|
1641 bltz xh, .Lle_xneg
|
|
|
1642
|
|
|
1643 /* Check if x <= y. */
|
|
|
1644 bltu xh, yh, 4f
|
|
|
1645 bne xh, yh, 5f
|
|
|
1646 bltu yl, xl, 5f
|
|
|
1647 4: movi a2, 0
|
|
|
1648 leaf_return
|
|
|
1649
|
|
|
1650 .Lle_xneg:
|
|
|
1651 /* Check if y <= x. */
|
|
|
1652 bltu yh, xh, 4b
|
|
|
1653 bne yh, xh, 5f
|
|
|
1654 bgeu xl, yl, 4b
|
|
|
1655 5: movi a2, 1
|
|
|
1656 leaf_return
|
|
|
1657
|
|
|
1658 .Lle_diff_signs:
|
|
|
1659 bltz xh, 4b
|
|
|
1660
|
|
|
1661 /* Check if both x and y are zero. */
|
|
|
1662 or a7, xh, yh
|
|
|
1663 slli a7, a7, 1
|
|
|
1664 or a7, a7, xl
|
|
|
1665 or a7, a7, yl
|
|
|
1666 movi a2, 1
|
|
|
1667 movi a3, 0
|
|
|
1668 moveqz a2, a3, a7
|
|
|
1669 leaf_return
|
|
|
1670
|
|
|
1671
|
|
|
1672 /* Greater Than or Equal */
|
|
|
1673
|
|
|
1674 .align 4
|
|
|
1675 .global __gedf2
|
|
|
1676 .type __gedf2, @function
|
|
|
1677 __gedf2:
|
|
|
1678 leaf_entry sp, 16
|
|
|
1679 movi a6, 0x7ff00000
|
|
|
1680 ball xh, a6, 2f
|
|
|
1681 1: bnall yh, a6, .Llt_cmp
|
|
|
1682
|
|
|
1683 /* Check if y is a NaN. */
|
|
|
1684 slli a7, yh, 12
|
|
|
1685 or a7, a7, yl
|
|
|
1686 beqz a7, .Llt_cmp
|
|
|
1687 movi a2, -1
|
|
|
1688 leaf_return
|
|
|
1689
|
|
|
1690 /* Check if x is a NaN. */
|
|
|
1691 2: slli a7, xh, 12
|
|
|
1692 or a7, a7, xl
|
|
|
1693 beqz a7, 1b
|
|
|
1694 movi a2, -1
|
|
|
1695 leaf_return
|
|
|
1696
|
|
|
1697
|
|
|
1698 /* Less Than */
|
|
|
1699
|
|
|
1700 .align 4
|
|
|
1701 .global __ltdf2
|
|
|
1702 .type __ltdf2, @function
|
|
|
1703 __ltdf2:
|
|
|
1704 leaf_entry sp, 16
|
|
|
1705 movi a6, 0x7ff00000
|
|
|
1706 ball xh, a6, 2f
|
|
|
1707 1: bnall yh, a6, .Llt_cmp
|
|
|
1708
|
|
|
1709 /* Check if y is a NaN. */
|
|
|
1710 slli a7, yh, 12
|
|
|
1711 or a7, a7, yl
|
|
|
1712 beqz a7, .Llt_cmp
|
|
|
1713 movi a2, 0
|
|
|
1714 leaf_return
|
|
|
1715
|
|
|
1716 /* Check if x is a NaN. */
|
|
|
1717 2: slli a7, xh, 12
|
|
|
1718 or a7, a7, xl
|
|
|
1719 beqz a7, 1b
|
|
|
1720 movi a2, 0
|
|
|
1721 leaf_return
|
|
|
1722
|
|
|
1723 .Llt_cmp:
|
|
|
1724 /* Check if x and y have different signs. */
|
|
|
1725 xor a7, xh, yh
|
|
|
1726 bltz a7, .Llt_diff_signs
|
|
|
1727
|
|
|
1728 /* Check if x is negative. */
|
|
|
1729 bltz xh, .Llt_xneg
|
|
|
1730
|
|
|
1731 /* Check if x < y. */
|
|
|
1732 bltu xh, yh, 4f
|
|
|
1733 bne xh, yh, 5f
|
|
|
1734 bgeu xl, yl, 5f
|
|
|
1735 4: movi a2, -1
|
|
|
1736 leaf_return
|
|
|
1737
|
|
|
1738 .Llt_xneg:
|
|
|
1739 /* Check if y < x. */
|
|
|
1740 bltu yh, xh, 4b
|
|
|
1741 bne yh, xh, 5f
|
|
|
1742 bltu yl, xl, 4b
|
|
|
1743 5: movi a2, 0
|
|
|
1744 leaf_return
|
|
|
1745
|
|
|
1746 .Llt_diff_signs:
|
|
|
1747 bgez xh, 5b
|
|
|
1748
|
|
|
1749 /* Check if both x and y are nonzero. */
|
|
|
1750 or a7, xh, yh
|
|
|
1751 slli a7, a7, 1
|
|
|
1752 or a7, a7, xl
|
|
|
1753 or a7, a7, yl
|
|
|
1754 movi a2, 0
|
|
|
1755 movi a3, -1
|
|
|
1756 movnez a2, a3, a7
|
|
|
1757 leaf_return
|
|
|
1758
|
|
|
1759
|
|
|
1760 /* Unordered */
|
|
|
1761
|
|
|
1762 .align 4
|
|
|
1763 .global __unorddf2
|
|
|
1764 .type __unorddf2, @function
|
|
|
1765 __unorddf2:
|
|
|
1766 leaf_entry sp, 16
|
|
|
1767 movi a6, 0x7ff00000
|
|
|
1768 ball xh, a6, 3f
|
|
|
1769 1: ball yh, a6, 4f
|
|
|
1770 2: movi a2, 0
|
|
|
1771 leaf_return
|
|
|
1772
|
|
|
1773 3: slli a7, xh, 12
|
|
|
1774 or a7, a7, xl
|
|
|
1775 beqz a7, 1b
|
|
|
1776 movi a2, 1
|
|
|
1777 leaf_return
|
|
|
1778
|
|
|
1779 4: slli a7, yh, 12
|
|
|
1780 or a7, a7, yl
|
|
|
1781 beqz a7, 2b
|
|
|
1782 movi a2, 1
|
|
|
1783 leaf_return
|
|
|
1784
|
|
|
1785 #endif /* L_cmpdf2 */
|
|
|
1786
|
|
|
1787 #ifdef L_fixdfsi
|
|
|
1788
|
|
|
1789 .align 4
|
|
|
1790 .global __fixdfsi
|
|
|
1791 .type __fixdfsi, @function
|
|
|
1792 __fixdfsi:
|
|
|
1793 leaf_entry sp, 16
|
|
|
1794
|
|
|
1795 /* Check for NaN and Infinity. */
|
|
|
1796 movi a6, 0x7ff00000
|
|
|
1797 ball xh, a6, .Lfixdfsi_nan_or_inf
|
|
|
1798
|
|
|
1799 /* Extract the exponent and check if 0 < (exp - 0x3fe) < 32. */
|
|
|
1800 extui a4, xh, 20, 11
|
|
|
1801 extui a5, a6, 19, 10 /* 0x3fe */
|
|
|
1802 sub a4, a4, a5
|
|
|
1803 bgei a4, 32, .Lfixdfsi_maxint
|
|
|
1804 blti a4, 1, .Lfixdfsi_zero
|
|
|
1805
|
|
|
1806 /* Add explicit "1.0" and shift << 11. */
|
|
|
1807 or a7, xh, a6
|
|
|
1808 ssai (32 - 11)
|
|
|
1809 src a5, a7, xl
|
|
|
1810
|
|
|
1811 /* Shift back to the right, based on the exponent. */
|
|
|
1812 ssl a4 /* shift by 32 - a4 */
|
|
|
1813 srl a5, a5
|
|
|
1814
|
|
|
1815 /* Negate the result if sign != 0. */
|
|
|
1816 neg a2, a5
|
|
|
1817 movgez a2, a5, a7
|
|
|
1818 leaf_return
|
|
|
1819
|
|
|
1820 .Lfixdfsi_nan_or_inf:
|
|
|
1821 /* Handle Infinity and NaN. */
|
|
|
1822 slli a4, xh, 12
|
|
|
1823 or a4, a4, xl
|
|
|
1824 beqz a4, .Lfixdfsi_maxint
|
|
|
1825
|
|
|
1826 /* Translate NaN to +maxint. */
|
|
|
1827 movi xh, 0
|
|
|
1828
|
|
|
1829 .Lfixdfsi_maxint:
|
|
|
1830 slli a4, a6, 11 /* 0x80000000 */
|
|
|
1831 addi a5, a4, -1 /* 0x7fffffff */
|
|
|
1832 movgez a4, a5, xh
|
|
|
1833 mov a2, a4
|
|
|
1834 leaf_return
|
|
|
1835
|
|
|
1836 .Lfixdfsi_zero:
|
|
|
1837 movi a2, 0
|
|
|
1838 leaf_return
|
|
|
1839
|
|
|
1840 #endif /* L_fixdfsi */
|
|
|
1841
|
|
|
1842 #ifdef L_fixdfdi
|
|
|
1843
|
|
|
1844 .align 4
|
|
|
1845 .global __fixdfdi
|
|
|
1846 .type __fixdfdi, @function
|
|
|
1847 __fixdfdi:
|
|
|
1848 leaf_entry sp, 16
|
|
|
1849
|
|
|
1850 /* Check for NaN and Infinity. */
|
|
|
1851 movi a6, 0x7ff00000
|
|
|
1852 ball xh, a6, .Lfixdfdi_nan_or_inf
|
|
|
1853
|
|
|
1854 /* Extract the exponent and check if 0 < (exp - 0x3fe) < 64. */
|
|
|
1855 extui a4, xh, 20, 11
|
|
|
1856 extui a5, a6, 19, 10 /* 0x3fe */
|
|
|
1857 sub a4, a4, a5
|
|
|
1858 bgei a4, 64, .Lfixdfdi_maxint
|
|
|
1859 blti a4, 1, .Lfixdfdi_zero
|
|
|
1860
|
|
|
1861 /* Add explicit "1.0" and shift << 11. */
|
|
|
1862 or a7, xh, a6
|
|
|
1863 ssai (32 - 11)
|
|
|
1864 src xh, a7, xl
|
|
|
1865 sll xl, xl
|
|
|
1866
|
|
|
1867 /* Shift back to the right, based on the exponent. */
|
|
|
1868 ssl a4 /* shift by 64 - a4 */
|
|
|
1869 bgei a4, 32, .Lfixdfdi_smallshift
|
|
|
1870 srl xl, xh
|
|
|
1871 movi xh, 0
|
|
|
1872
|
|
|
1873 .Lfixdfdi_shifted:
|
|
|
1874 /* Negate the result if sign != 0. */
|
|
|
1875 bgez a7, 1f
|
|
|
1876 neg xl, xl
|
|
|
1877 neg xh, xh
|
|
|
1878 beqz xl, 1f
|
|
|
1879 addi xh, xh, -1
|
|
|
1880 1: leaf_return
|
|
|
1881
|
|
|
1882 .Lfixdfdi_smallshift:
|
|
|
1883 src xl, xh, xl
|
|
|
1884 srl xh, xh
|
|
|
1885 j .Lfixdfdi_shifted
|
|
|
1886
|
|
|
1887 .Lfixdfdi_nan_or_inf:
|
|
|
1888 /* Handle Infinity and NaN. */
|
|
|
1889 slli a4, xh, 12
|
|
|
1890 or a4, a4, xl
|
|
|
1891 beqz a4, .Lfixdfdi_maxint
|
|
|
1892
|
|
|
1893 /* Translate NaN to +maxint. */
|
|
|
1894 movi xh, 0
|
|
|
1895
|
|
|
1896 .Lfixdfdi_maxint:
|
|
|
1897 slli a7, a6, 11 /* 0x80000000 */
|
|
|
1898 bgez xh, 1f
|
|
|
1899 mov xh, a7
|
|
|
1900 movi xl, 0
|
|
|
1901 leaf_return
|
|
|
1902
|
|
|
1903 1: addi xh, a7, -1 /* 0x7fffffff */
|
|
|
1904 movi xl, -1
|
|
|
1905 leaf_return
|
|
|
1906
|
|
|
1907 .Lfixdfdi_zero:
|
|
|
1908 movi xh, 0
|
|
|
1909 movi xl, 0
|
|
|
1910 leaf_return
|
|
|
1911
|
|
|
1912 #endif /* L_fixdfdi */
|
|
|
1913
|
|
|
1914 #ifdef L_fixunsdfsi
|
|
|
1915
|
|
|
1916 .align 4
|
|
|
1917 .global __fixunsdfsi
|
|
|
1918 .type __fixunsdfsi, @function
|
|
|
1919 __fixunsdfsi:
|
|
|
1920 leaf_entry sp, 16
|
|
|
1921
|
|
|
1922 /* Check for NaN and Infinity. */
|
|
|
1923 movi a6, 0x7ff00000
|
|
|
1924 ball xh, a6, .Lfixunsdfsi_nan_or_inf
|
|
|
1925
|
|
|
1926 /* Extract the exponent and check if 0 <= (exp - 0x3ff) < 32. */
|
|
|
1927 extui a4, xh, 20, 11
|
|
|
1928 extui a5, a6, 20, 10 /* 0x3ff */
|
|
|
1929 sub a4, a4, a5
|
|
|
1930 bgei a4, 32, .Lfixunsdfsi_maxint
|
|
|
1931 bltz a4, .Lfixunsdfsi_zero
|
|
|
1932
|
|
|
1933 /* Add explicit "1.0" and shift << 11. */
|
|
|
1934 or a7, xh, a6
|
|
|
1935 ssai (32 - 11)
|
|
|
1936 src a5, a7, xl
|
|
|
1937
|
|
|
1938 /* Shift back to the right, based on the exponent. */
|
|
|
1939 addi a4, a4, 1
|
|
|
1940 beqi a4, 32, .Lfixunsdfsi_bigexp
|
|
|
1941 ssl a4 /* shift by 32 - a4 */
|
|
|
1942 srl a5, a5
|
|
|
1943
|
|
|
1944 /* Negate the result if sign != 0. */
|
|
|
1945 neg a2, a5
|
|
|
1946 movgez a2, a5, a7
|
|
|
1947 leaf_return
|
|
|
1948
|
|
|
1949 .Lfixunsdfsi_nan_or_inf:
|
|
|
1950 /* Handle Infinity and NaN. */
|
|
|
1951 slli a4, xh, 12
|
|
|
1952 or a4, a4, xl
|
|
|
1953 beqz a4, .Lfixunsdfsi_maxint
|
|
|
1954
|
|
|
1955 /* Translate NaN to 0xffffffff. */
|
|
|
1956 movi a2, -1
|
|
|
1957 leaf_return
|
|
|
1958
|
|
|
1959 .Lfixunsdfsi_maxint:
|
|
|
1960 slli a4, a6, 11 /* 0x80000000 */
|
|
|
1961 movi a5, -1 /* 0xffffffff */
|
|
|
1962 movgez a4, a5, xh
|
|
|
1963 mov a2, a4
|
|
|
1964 leaf_return
|
|
|
1965
|
|
|
1966 .Lfixunsdfsi_zero:
|
|
|
1967 movi a2, 0
|
|
|
1968 leaf_return
|
|
|
1969
|
|
|
1970 .Lfixunsdfsi_bigexp:
|
|
|
1971 /* Handle unsigned maximum exponent case. */
|
|
|
1972 bltz xh, 1f
|
|
|
1973 mov a2, a5 /* no shift needed */
|
|
|
1974 leaf_return
|
|
|
1975
|
|
|
1976 /* Return 0x80000000 if negative. */
|
|
|
1977 1: slli a2, a6, 11
|
|
|
1978 leaf_return
|
|
|
1979
|
|
|
1980 #endif /* L_fixunsdfsi */
|
|
|
1981
|
|
|
1982 #ifdef L_fixunsdfdi
|
|
|
1983
|
|
|
1984 .align 4
|
|
|
1985 .global __fixunsdfdi
|
|
|
1986 .type __fixunsdfdi, @function
|
|
|
1987 __fixunsdfdi:
|
|
|
1988 leaf_entry sp, 16
|
|
|
1989
|
|
|
1990 /* Check for NaN and Infinity. */
|
|
|
1991 movi a6, 0x7ff00000
|
|
|
1992 ball xh, a6, .Lfixunsdfdi_nan_or_inf
|
|
|
1993
|
|
|
1994 /* Extract the exponent and check if 0 <= (exp - 0x3ff) < 64. */
|
|
|
1995 extui a4, xh, 20, 11
|
|
|
1996 extui a5, a6, 20, 10 /* 0x3ff */
|
|
|
1997 sub a4, a4, a5
|
|
|
1998 bgei a4, 64, .Lfixunsdfdi_maxint
|
|
|
1999 bltz a4, .Lfixunsdfdi_zero
|
|
|
2000
|
|
|
2001 /* Add explicit "1.0" and shift << 11. */
|
|
|
2002 or a7, xh, a6
|
|
|
2003 ssai (32 - 11)
|
|
|
2004 src xh, a7, xl
|
|
|
2005 sll xl, xl
|
|
|
2006
|
|
|
2007 /* Shift back to the right, based on the exponent. */
|
|
|
2008 addi a4, a4, 1
|
|
|
2009 beqi a4, 64, .Lfixunsdfdi_bigexp
|
|
|
2010 ssl a4 /* shift by 64 - a4 */
|
|
|
2011 bgei a4, 32, .Lfixunsdfdi_smallshift
|
|
|
2012 srl xl, xh
|
|
|
2013 movi xh, 0
|
|
|
2014
|
|
|
2015 .Lfixunsdfdi_shifted:
|
|
|
2016 /* Negate the result if sign != 0. */
|
|
|
2017 bgez a7, 1f
|
|
|
2018 neg xl, xl
|
|
|
2019 neg xh, xh
|
|
|
2020 beqz xl, 1f
|
|
|
2021 addi xh, xh, -1
|
|
|
2022 1: leaf_return
|
|
|
2023
|
|
|
2024 .Lfixunsdfdi_smallshift:
|
|
|
2025 src xl, xh, xl
|
|
|
2026 srl xh, xh
|
|
|
2027 j .Lfixunsdfdi_shifted
|
|
|
2028
|
|
|
2029 .Lfixunsdfdi_nan_or_inf:
|
|
|
2030 /* Handle Infinity and NaN. */
|
|
|
2031 slli a4, xh, 12
|
|
|
2032 or a4, a4, xl
|
|
|
2033 beqz a4, .Lfixunsdfdi_maxint
|
|
|
2034
|
|
|
2035 /* Translate NaN to 0xffffffff.... */
|
|
|
2036 1: movi xh, -1
|
|
|
2037 movi xl, -1
|
|
|
2038 leaf_return
|
|
|
2039
|
|
|
2040 .Lfixunsdfdi_maxint:
|
|
|
2041 bgez xh, 1b
|
|
|
2042 2: slli xh, a6, 11 /* 0x80000000 */
|
|
|
2043 movi xl, 0
|
|
|
2044 leaf_return
|
|
|
2045
|
|
|
2046 .Lfixunsdfdi_zero:
|
|
|
2047 movi xh, 0
|
|
|
2048 movi xl, 0
|
|
|
2049 leaf_return
|
|
|
2050
|
|
|
2051 .Lfixunsdfdi_bigexp:
|
|
|
2052 /* Handle unsigned maximum exponent case. */
|
|
|
2053 bltz a7, 2b
|
|
|
2054 leaf_return /* no shift needed */
|
|
|
2055
|
|
|
2056 #endif /* L_fixunsdfdi */
|
|
|
2057
|
|
|
2058 #ifdef L_floatsidf
|
|
|
2059
|
|
|
2060 .align 4
|
|
|
2061 .global __floatunsidf
|
|
|
2062 .type __floatunsidf, @function
|
|
|
2063 __floatunsidf:
|
|
|
2064 leaf_entry sp, 16
|
|
|
2065 beqz a2, .Lfloatsidf_return_zero
|
|
|
2066
|
|
|
2067 /* Set the sign to zero and jump to the floatsidf code. */
|
|
|
2068 movi a7, 0
|
|
|
2069 j .Lfloatsidf_normalize
|
|
|
2070
|
|
|
2071 .align 4
|
|
|
2072 .global __floatsidf
|
|
|
2073 .type __floatsidf, @function
|
|
|
2074 __floatsidf:
|
|
|
2075 leaf_entry sp, 16
|
|
|
2076
|
|
|
2077 /* Check for zero. */
|
|
|
2078 beqz a2, .Lfloatsidf_return_zero
|
|
|
2079
|
|
|
2080 /* Save the sign. */
|
|
|
2081 extui a7, a2, 31, 1
|
|
|
2082
|
|
|
2083 /* Get the absolute value. */
|
|
|
2084 #if XCHAL_HAVE_ABS
|
|
|
2085 abs a2, a2
|
|
|
2086 #else
|
|
|
2087 neg a4, a2
|
|
|
2088 movltz a2, a4, a2
|
|
|
2089 #endif
|
|
|
2090
|
|
|
2091 .Lfloatsidf_normalize:
|
|
|
2092 /* Normalize with the first 1 bit in the msb. */
|
|
|
2093 do_nsau a4, a2, a5, a6
|
|
|
2094 ssl a4
|
|
|
2095 sll a5, a2
|
|
|
2096
|
|
|
2097 /* Shift the mantissa into position. */
|
|
|
2098 srli xh, a5, 11
|
|
|
2099 slli xl, a5, (32 - 11)
|
|
|
2100
|
|
|
2101 /* Set the exponent. */
|
|
|
2102 movi a5, 0x41d /* 0x3fe + 31 */
|
|
|
2103 sub a5, a5, a4
|
|
|
2104 slli a5, a5, 20
|
|
|
2105 add xh, xh, a5
|
|
|
2106
|
|
|
2107 /* Add the sign and return. */
|
|
|
2108 slli a7, a7, 31
|
|
|
2109 or xh, xh, a7
|
|
|
2110 leaf_return
|
|
|
2111
|
|
|
2112 .Lfloatsidf_return_zero:
|
|
|
2113 movi a3, 0
|
|
|
2114 leaf_return
|
|
|
2115
|
|
|
2116 #endif /* L_floatsidf */
|
|
|
2117
|
|
|
2118 #ifdef L_floatdidf
|
|
|
2119
|
|
|
2120 .align 4
|
|
|
2121 .global __floatundidf
|
|
|
2122 .type __floatundidf, @function
|
|
|
2123 __floatundidf:
|
|
|
2124 leaf_entry sp, 16
|
|
|
2125
|
|
|
2126 /* Check for zero. */
|
|
|
2127 or a4, xh, xl
|
|
|
2128 beqz a4, 2f
|
|
|
2129
|
|
|
2130 /* Set the sign to zero and jump to the floatdidf code. */
|
|
|
2131 movi a7, 0
|
|
|
2132 j .Lfloatdidf_normalize
|
|
|
2133
|
|
|
2134 .align 4
|
|
|
2135 .global __floatdidf
|
|
|
2136 .type __floatdidf, @function
|
|
|
2137 __floatdidf:
|
|
|
2138 leaf_entry sp, 16
|
|
|
2139
|
|
|
2140 /* Check for zero. */
|
|
|
2141 or a4, xh, xl
|
|
|
2142 beqz a4, 2f
|
|
|
2143
|
|
|
2144 /* Save the sign. */
|
|
|
2145 extui a7, xh, 31, 1
|
|
|
2146
|
|
|
2147 /* Get the absolute value. */
|
|
|
2148 bgez xh, .Lfloatdidf_normalize
|
|
|
2149 neg xl, xl
|
|
|
2150 neg xh, xh
|
|
|
2151 beqz xl, .Lfloatdidf_normalize
|
|
|
2152 addi xh, xh, -1
|
|
|
2153
|
|
|
2154 .Lfloatdidf_normalize:
|
|
|
2155 /* Normalize with the first 1 bit in the msb of xh. */
|
|
|
2156 beqz xh, .Lfloatdidf_bigshift
|
|
|
2157 do_nsau a4, xh, a5, a6
|
|
|
2158 ssl a4
|
|
|
2159 src xh, xh, xl
|
|
|
2160 sll xl, xl
|
|
|
2161
|
|
|
2162 .Lfloatdidf_shifted:
|
|
|
2163 /* Shift the mantissa into position, with rounding bits in a6. */
|
|
|
2164 ssai 11
|
|
|
2165 sll a6, xl
|
|
|
2166 src xl, xh, xl
|
|
|
2167 srl xh, xh
|
|
|
2168
|
|
|
2169 /* Set the exponent. */
|
|
|
2170 movi a5, 0x43d /* 0x3fe + 63 */
|
|
|
2171 sub a5, a5, a4
|
|
|
2172 slli a5, a5, 20
|
|
|
2173 add xh, xh, a5
|
|
|
2174
|
|
|
2175 /* Add the sign. */
|
|
|
2176 slli a7, a7, 31
|
|
|
2177 or xh, xh, a7
|
|
|
2178
|
|
|
2179 /* Round up if the leftover fraction is >= 1/2. */
|
|
|
2180 bgez a6, 2f
|
|
|
2181 addi xl, xl, 1
|
|
|
2182 beqz xl, .Lfloatdidf_roundcarry
|
|
|
2183
|
|
|
2184 /* Check if the leftover fraction is exactly 1/2. */
|
|
|
2185 slli a6, a6, 1
|
|
|
2186 beqz a6, .Lfloatdidf_exactlyhalf
|
|
|
2187 2: leaf_return
|
|
|
2188
|
|
|
2189 .Lfloatdidf_bigshift:
|
|
|
2190 /* xh is zero. Normalize with first 1 bit of xl in the msb of xh. */
|
|
|
2191 do_nsau a4, xl, a5, a6
|
|
|
2192 ssl a4
|
|
|
2193 sll xh, xl
|
|
|
2194 movi xl, 0
|
|
|
2195 addi a4, a4, 32
|
|
|
2196 j .Lfloatdidf_shifted
|
|
|
2197
|
|
|
2198 .Lfloatdidf_exactlyhalf:
|
|
|
2199 /* Round down to the nearest even value. */
|
|
|
2200 srli xl, xl, 1
|
|
|
2201 slli xl, xl, 1
|
|
|
2202 leaf_return
|
|
|
2203
|
|
|
2204 .Lfloatdidf_roundcarry:
|
|
|
2205 /* xl is always zero when the rounding increment overflows, so
|
|
|
2206 there's no need to round it to an even value. */
|
|
|
2207 addi xh, xh, 1
|
|
|
2208 /* Overflow to the exponent is OK. */
|
|
|
2209 leaf_return
|
|
|
2210
|
|
|
2211 #endif /* L_floatdidf */
|
|
|
2212
|
|
|
2213 #ifdef L_truncdfsf2
|
|
|
2214
|
|
|
2215 .align 4
|
|
|
2216 .global __truncdfsf2
|
|
|
2217 .type __truncdfsf2, @function
|
|
|
2218 __truncdfsf2:
|
|
|
2219 leaf_entry sp, 16
|
|
|
2220
|
|
|
2221 /* Adjust the exponent bias. */
|
|
|
2222 movi a4, (0x3ff - 0x7f) << 20
|
|
|
2223 sub a5, xh, a4
|
|
|
2224
|
|
|
2225 /* Check for underflow. */
|
|
|
2226 xor a6, xh, a5
|
|
|
2227 bltz a6, .Ltrunc_underflow
|
|
|
2228 extui a6, a5, 20, 11
|
|
|
2229 beqz a6, .Ltrunc_underflow
|
|
|
2230
|
|
|
2231 /* Check for overflow. */
|
|
|
2232 movi a4, 255
|
|
|
2233 bge a6, a4, .Ltrunc_overflow
|
|
|
2234
|
|
|
2235 /* Shift a5/xl << 3 into a5/a4. */
|
|
|
2236 ssai (32 - 3)
|
|
|
2237 src a5, a5, xl
|
|
|
2238 sll a4, xl
|
|
|
2239
|
|
|
2240 .Ltrunc_addsign:
|
|
|
2241 /* Add the sign bit. */
|
|
|
2242 extui a6, xh, 31, 1
|
|
|
2243 slli a6, a6, 31
|
|
|
2244 or a2, a6, a5
|
|
|
2245
|
|
|
2246 /* Round up if the leftover fraction is >= 1/2. */
|
|
|
2247 bgez a4, 1f
|
|
|
2248 addi a2, a2, 1
|
|
|
2249 /* Overflow to the exponent is OK. The answer will be correct. */
|
|
|
2250
|
|
|
2251 /* Check if the leftover fraction is exactly 1/2. */
|
|
|
2252 slli a4, a4, 1
|
|
|
2253 beqz a4, .Ltrunc_exactlyhalf
|
|
|
2254 1: leaf_return
|
|
|
2255
|
|
|
2256 .Ltrunc_exactlyhalf:
|
|
|
2257 /* Round down to the nearest even value. */
|
|
|
2258 srli a2, a2, 1
|
|
|
2259 slli a2, a2, 1
|
|
|
2260 leaf_return
|
|
|
2261
|
|
|
2262 .Ltrunc_overflow:
|
|
|
2263 /* Check if exponent == 0x7ff. */
|
|
|
2264 movi a4, 0x7ff00000
|
|
|
2265 bnall xh, a4, 1f
|
|
|
2266
|
|
|
2267 /* Check if mantissa is nonzero. */
|
|
|
2268 slli a5, xh, 12
|
|
|
2269 or a5, a5, xl
|
|
|
2270 beqz a5, 1f
|
|
|
2271
|
|
|
2272 /* Shift a4 to set a bit in the mantissa, making a quiet NaN. */
|
|
|
2273 srli a4, a4, 1
|
|
|
2274
|
|
|
2275 1: slli a4, a4, 4 /* 0xff000000 or 0xff800000 */
|
|
|
2276 /* Add the sign bit. */
|
|
|
2277 extui a6, xh, 31, 1
|
|
|
2278 ssai 1
|
|
|
2279 src a2, a6, a4
|
|
|
2280 leaf_return
|
|
|
2281
|
|
|
2282 .Ltrunc_underflow:
|
|
|
2283 /* Find shift count for a subnormal. Flush to zero if >= 32. */
|
|
|
2284 extui a6, xh, 20, 11
|
|
|
2285 movi a5, 0x3ff - 0x7f
|
|
|
2286 sub a6, a5, a6
|
|
|
2287 addi a6, a6, 1
|
|
|
2288 bgeui a6, 32, 1f
|
|
|
2289
|
|
|
2290 /* Replace the exponent with an explicit "1.0". */
|
|
|
2291 slli a5, a5, 13 /* 0x700000 */
|
|
|
2292 or a5, a5, xh
|
|
|
2293 slli a5, a5, 11
|
|
|
2294 srli a5, a5, 11
|
|
|
2295
|
|
|
2296 /* Shift the mantissa left by 3 bits (into a5/a4). */
|
|
|
2297 ssai (32 - 3)
|
|
|
2298 src a5, a5, xl
|
|
|
2299 sll a4, xl
|
|
|
2300
|
|
|
2301 /* Shift right by a6. */
|
|
|
2302 ssr a6
|
|
|
2303 sll a7, a4
|
|
|
2304 src a4, a5, a4
|
|
|
2305 srl a5, a5
|
|
|
2306 beqz a7, .Ltrunc_addsign
|
|
|
2307 or a4, a4, a6 /* any positive, nonzero value will work */
|
|
|
2308 j .Ltrunc_addsign
|
|
|
2309
|
|
|
2310 /* Return +/- zero. */
|
|
|
2311 1: extui a2, xh, 31, 1
|
|
|
2312 slli a2, a2, 31
|
|
|
2313 leaf_return
|
|
|
2314
|
|
|
2315 #endif /* L_truncdfsf2 */
|
|
|
2316
|
|
|
2317 #ifdef L_extendsfdf2
|
|
|
2318
|
|
|
2319 .align 4
|
|
|
2320 .global __extendsfdf2
|
|
|
2321 .type __extendsfdf2, @function
|
|
|
2322 __extendsfdf2:
|
|
|
2323 leaf_entry sp, 16
|
|
|
2324
|
|
|
2325 /* Save the sign bit and then shift it off. */
|
|
|
2326 extui a5, a2, 31, 1
|
|
|
2327 slli a5, a5, 31
|
|
|
2328 slli a4, a2, 1
|
|
|
2329
|
|
|
2330 /* Extract and check the exponent. */
|
|
|
2331 extui a6, a2, 23, 8
|
|
|
2332 beqz a6, .Lextend_expzero
|
|
|
2333 addi a6, a6, 1
|
|
|
2334 beqi a6, 256, .Lextend_nan_or_inf
|
|
|
2335
|
|
|
2336 /* Shift >> 3 into a4/xl. */
|
|
|
2337 srli a4, a4, 4
|
|
|
2338 slli xl, a2, (32 - 3)
|
|
|
2339
|
|
|
2340 /* Adjust the exponent bias. */
|
|
|
2341 movi a6, (0x3ff - 0x7f) << 20
|
|
|
2342 add a4, a4, a6
|
|
|
2343
|
|
|
2344 /* Add the sign bit. */
|
|
|
2345 or xh, a4, a5
|
|
|
2346 leaf_return
|
|
|
2347
|
|
|
2348 .Lextend_nan_or_inf:
|
|
|
2349 movi a4, 0x7ff00000
|
|
|
2350
|
|
|
2351 /* Check for NaN. */
|
|
|
2352 slli a7, a2, 9
|
|
|
2353 beqz a7, 1f
|
|
|
2354
|
|
|
2355 slli a6, a6, 11 /* 0x80000 */
|
|
|
2356 or a4, a4, a6
|
|
|
2357
|
|
|
2358 /* Add the sign and return. */
|
|
|
2359 1: or xh, a4, a5
|
|
|
2360 movi xl, 0
|
|
|
2361 leaf_return
|
|
|
2362
|
|
|
2363 .Lextend_expzero:
|
|
|
2364 beqz a4, 1b
|
|
|
2365
|
|
|
2366 /* Normalize it to have 8 zero bits before the first 1 bit. */
|
|
|
2367 do_nsau a7, a4, a2, a3
|
|
|
2368 addi a7, a7, -8
|
|
|
2369 ssl a7
|
|
|
2370 sll a4, a4
|
|
|
2371
|
|
|
2372 /* Shift >> 3 into a4/xl. */
|
|
|
2373 slli xl, a4, (32 - 3)
|
|
|
2374 srli a4, a4, 3
|
|
|
2375
|
|
|
2376 /* Set the exponent. */
|
|
|
2377 movi a6, 0x3fe - 0x7f
|
|
|
2378 sub a6, a6, a7
|
|
|
2379 slli a6, a6, 20
|
|
|
2380 add a4, a4, a6
|
|
|
2381
|
|
|
2382 /* Add the sign and return. */
|
|
|
2383 or xh, a4, a5
|
|
|
2384 leaf_return
|
|
|
2385
|
|
|
2386 #endif /* L_extendsfdf2 */
|
|
|
2387
|
|
|
2388
|
