|
0
|
1 /* More subroutines needed by GCC output code on some machines. */
|
|
|
2 /* Compile this one with gcc. */
|
|
|
3 /* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
|
|
4 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
|
|
|
5 Free Software Foundation, Inc.
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
9 GCC is free software; you can redistribute it and/or modify it under
|
|
|
10 the terms of the GNU General Public License as published by the Free
|
|
|
11 Software Foundation; either version 3, or (at your option) any later
|
|
|
12 version.
|
|
|
13
|
|
|
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
17 for more details.
|
|
|
18
|
|
|
19 Under Section 7 of GPL version 3, you are granted additional
|
|
|
20 permissions described in the GCC Runtime Library Exception, version
|
|
|
21 3.1, as published by the Free Software Foundation.
|
|
|
22
|
|
|
23 You should have received a copy of the GNU General Public License and
|
|
|
24 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
25 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
26 <http://www.gnu.org/licenses/>. */
|
|
|
27
|
|
|
28 #include "tconfig.h"
|
|
|
29 #include "tsystem.h"
|
|
|
30 #include "coretypes.h"
|
|
|
31 #include "tm.h"
|
|
|
32
|
|
|
33 #ifdef HAVE_GAS_HIDDEN
|
|
|
34 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
|
|
|
35 #else
|
|
|
36 #define ATTRIBUTE_HIDDEN
|
|
|
37 #endif
|
|
|
38
|
|
|
39 #ifndef MIN_UNITS_PER_WORD
|
|
|
40 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
|
|
|
41 #endif
|
|
|
42
|
|
|
43 /* Work out the largest "word" size that we can deal with on this target. */
|
|
|
44 #if MIN_UNITS_PER_WORD > 4
|
|
|
45 # define LIBGCC2_MAX_UNITS_PER_WORD 8
|
|
|
46 #elif (MIN_UNITS_PER_WORD > 2 \
|
|
|
47 || (MIN_UNITS_PER_WORD > 1 && LONG_LONG_TYPE_SIZE > 32))
|
|
|
48 # define LIBGCC2_MAX_UNITS_PER_WORD 4
|
|
|
49 #else
|
|
|
50 # define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
|
|
|
51 #endif
|
|
|
52
|
|
|
53 /* Work out what word size we are using for this compilation.
|
|
|
54 The value can be set on the command line. */
|
|
|
55 #ifndef LIBGCC2_UNITS_PER_WORD
|
|
|
56 #define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD
|
|
|
57 #endif
|
|
|
58
|
|
|
59 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
|
|
|
60
|
|
|
61 #include "libgcc2.h"
|
|
|
62
|
|
|
63 #ifdef DECLARE_LIBRARY_RENAMES
|
|
|
64 DECLARE_LIBRARY_RENAMES
|
|
|
65 #endif
|
|
|
66
|
|
|
67 #if defined (L_negdi2)
|
|
|
68 DWtype
|
|
|
69 __negdi2 (DWtype u)
|
|
|
70 {
|
|
|
71 const DWunion uu = {.ll = u};
|
|
|
72 const DWunion w = { {.low = -uu.s.low,
|
|
|
73 .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
|
|
|
74
|
|
|
75 return w.ll;
|
|
|
76 }
|
|
|
77 #endif
|
|
|
78
|
|
|
79 #ifdef L_addvsi3
|
|
|
80 Wtype
|
|
|
81 __addvSI3 (Wtype a, Wtype b)
|
|
|
82 {
|
|
|
83 const Wtype w = (UWtype) a + (UWtype) b;
|
|
|
84
|
|
|
85 if (b >= 0 ? w < a : w > a)
|
|
|
86 abort ();
|
|
|
87
|
|
|
88 return w;
|
|
|
89 }
|
|
|
90 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
|
|
|
91 SItype
|
|
|
92 __addvsi3 (SItype a, SItype b)
|
|
|
93 {
|
|
|
94 const SItype w = (USItype) a + (USItype) b;
|
|
|
95
|
|
|
96 if (b >= 0 ? w < a : w > a)
|
|
|
97 abort ();
|
|
|
98
|
|
|
99 return w;
|
|
|
100 }
|
|
|
101 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
|
|
|
102 #endif
|
|
|
103
|
|
|
104 #ifdef L_addvdi3
|
|
|
105 DWtype
|
|
|
106 __addvDI3 (DWtype a, DWtype b)
|
|
|
107 {
|
|
|
108 const DWtype w = (UDWtype) a + (UDWtype) b;
|
|
|
109
|
|
|
110 if (b >= 0 ? w < a : w > a)
|
|
|
111 abort ();
|
|
|
112
|
|
|
113 return w;
|
|
|
114 }
|
|
|
115 #endif
|
|
|
116
|
|
|
117 #ifdef L_subvsi3
|
|
|
118 Wtype
|
|
|
119 __subvSI3 (Wtype a, Wtype b)
|
|
|
120 {
|
|
|
121 const Wtype w = (UWtype) a - (UWtype) b;
|
|
|
122
|
|
|
123 if (b >= 0 ? w > a : w < a)
|
|
|
124 abort ();
|
|
|
125
|
|
|
126 return w;
|
|
|
127 }
|
|
|
128 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
|
|
|
129 SItype
|
|
|
130 __subvsi3 (SItype a, SItype b)
|
|
|
131 {
|
|
|
132 const SItype w = (USItype) a - (USItype) b;
|
|
|
133
|
|
|
134 if (b >= 0 ? w > a : w < a)
|
|
|
135 abort ();
|
|
|
136
|
|
|
137 return w;
|
|
|
138 }
|
|
|
139 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
|
|
|
140 #endif
|
|
|
141
|
|
|
142 #ifdef L_subvdi3
|
|
|
143 DWtype
|
|
|
144 __subvDI3 (DWtype a, DWtype b)
|
|
|
145 {
|
|
|
146 const DWtype w = (UDWtype) a - (UDWtype) b;
|
|
|
147
|
|
|
148 if (b >= 0 ? w > a : w < a)
|
|
|
149 abort ();
|
|
|
150
|
|
|
151 return w;
|
|
|
152 }
|
|
|
153 #endif
|
|
|
154
|
|
|
155 #ifdef L_mulvsi3
|
|
|
156 Wtype
|
|
|
157 __mulvSI3 (Wtype a, Wtype b)
|
|
|
158 {
|
|
|
159 const DWtype w = (DWtype) a * (DWtype) b;
|
|
|
160
|
|
|
161 if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
|
|
|
162 abort ();
|
|
|
163
|
|
|
164 return w;
|
|
|
165 }
|
|
|
166 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
|
|
|
167 #undef WORD_SIZE
|
|
|
168 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
|
|
|
169 SItype
|
|
|
170 __mulvsi3 (SItype a, SItype b)
|
|
|
171 {
|
|
|
172 const DItype w = (DItype) a * (DItype) b;
|
|
|
173
|
|
|
174 if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1))
|
|
|
175 abort ();
|
|
|
176
|
|
|
177 return w;
|
|
|
178 }
|
|
|
179 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
|
|
|
180 #endif
|
|
|
181
|
|
|
182 #ifdef L_negvsi2
|
|
|
183 Wtype
|
|
|
184 __negvSI2 (Wtype a)
|
|
|
185 {
|
|
|
186 const Wtype w = -(UWtype) a;
|
|
|
187
|
|
|
188 if (a >= 0 ? w > 0 : w < 0)
|
|
|
189 abort ();
|
|
|
190
|
|
|
191 return w;
|
|
|
192 }
|
|
|
193 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
|
|
|
194 SItype
|
|
|
195 __negvsi2 (SItype a)
|
|
|
196 {
|
|
|
197 const SItype w = -(USItype) a;
|
|
|
198
|
|
|
199 if (a >= 0 ? w > 0 : w < 0)
|
|
|
200 abort ();
|
|
|
201
|
|
|
202 return w;
|
|
|
203 }
|
|
|
204 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
|
|
|
205 #endif
|
|
|
206
|
|
|
207 #ifdef L_negvdi2
|
|
|
208 DWtype
|
|
|
209 __negvDI2 (DWtype a)
|
|
|
210 {
|
|
|
211 const DWtype w = -(UDWtype) a;
|
|
|
212
|
|
|
213 if (a >= 0 ? w > 0 : w < 0)
|
|
|
214 abort ();
|
|
|
215
|
|
|
216 return w;
|
|
|
217 }
|
|
|
218 #endif
|
|
|
219
|
|
|
220 #ifdef L_absvsi2
|
|
|
221 Wtype
|
|
|
222 __absvSI2 (Wtype a)
|
|
|
223 {
|
|
|
224 Wtype w = a;
|
|
|
225
|
|
|
226 if (a < 0)
|
|
|
227 #ifdef L_negvsi2
|
|
|
228 w = __negvSI2 (a);
|
|
|
229 #else
|
|
|
230 w = -(UWtype) a;
|
|
|
231
|
|
|
232 if (w < 0)
|
|
|
233 abort ();
|
|
|
234 #endif
|
|
|
235
|
|
|
236 return w;
|
|
|
237 }
|
|
|
238 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
|
|
|
239 SItype
|
|
|
240 __absvsi2 (SItype a)
|
|
|
241 {
|
|
|
242 SItype w = a;
|
|
|
243
|
|
|
244 if (a < 0)
|
|
|
245 #ifdef L_negvsi2
|
|
|
246 w = __negvsi2 (a);
|
|
|
247 #else
|
|
|
248 w = -(USItype) a;
|
|
|
249
|
|
|
250 if (w < 0)
|
|
|
251 abort ();
|
|
|
252 #endif
|
|
|
253
|
|
|
254 return w;
|
|
|
255 }
|
|
|
256 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
|
|
|
257 #endif
|
|
|
258
|
|
|
259 #ifdef L_absvdi2
|
|
|
260 DWtype
|
|
|
261 __absvDI2 (DWtype a)
|
|
|
262 {
|
|
|
263 DWtype w = a;
|
|
|
264
|
|
|
265 if (a < 0)
|
|
|
266 #ifdef L_negvdi2
|
|
|
267 w = __negvDI2 (a);
|
|
|
268 #else
|
|
|
269 w = -(UDWtype) a;
|
|
|
270
|
|
|
271 if (w < 0)
|
|
|
272 abort ();
|
|
|
273 #endif
|
|
|
274
|
|
|
275 return w;
|
|
|
276 }
|
|
|
277 #endif
|
|
|
278
|
|
|
279 #ifdef L_mulvdi3
|
|
|
280 DWtype
|
|
|
281 __mulvDI3 (DWtype u, DWtype v)
|
|
|
282 {
|
|
|
283 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
|
|
|
284 but the checked multiplication needs only two. */
|
|
|
285 const DWunion uu = {.ll = u};
|
|
|
286 const DWunion vv = {.ll = v};
|
|
|
287
|
|
|
288 if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
|
|
|
289 {
|
|
|
290 /* u fits in a single Wtype. */
|
|
|
291 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
|
|
|
292 {
|
|
|
293 /* v fits in a single Wtype as well. */
|
|
|
294 /* A single multiplication. No overflow risk. */
|
|
|
295 return (DWtype) uu.s.low * (DWtype) vv.s.low;
|
|
|
296 }
|
|
|
297 else
|
|
|
298 {
|
|
|
299 /* Two multiplications. */
|
|
|
300 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
301 * (UDWtype) (UWtype) vv.s.low};
|
|
|
302 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
303 * (UDWtype) (UWtype) vv.s.high};
|
|
|
304
|
|
|
305 if (vv.s.high < 0)
|
|
|
306 w1.s.high -= uu.s.low;
|
|
|
307 if (uu.s.low < 0)
|
|
|
308 w1.ll -= vv.ll;
|
|
|
309 w1.ll += (UWtype) w0.s.high;
|
|
|
310 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
|
|
|
311 {
|
|
|
312 w0.s.high = w1.s.low;
|
|
|
313 return w0.ll;
|
|
|
314 }
|
|
|
315 }
|
|
|
316 }
|
|
|
317 else
|
|
|
318 {
|
|
|
319 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
|
|
|
320 {
|
|
|
321 /* v fits into a single Wtype. */
|
|
|
322 /* Two multiplications. */
|
|
|
323 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
324 * (UDWtype) (UWtype) vv.s.low};
|
|
|
325 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high
|
|
|
326 * (UDWtype) (UWtype) vv.s.low};
|
|
|
327
|
|
|
328 if (uu.s.high < 0)
|
|
|
329 w1.s.high -= vv.s.low;
|
|
|
330 if (vv.s.low < 0)
|
|
|
331 w1.ll -= uu.ll;
|
|
|
332 w1.ll += (UWtype) w0.s.high;
|
|
|
333 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
|
|
|
334 {
|
|
|
335 w0.s.high = w1.s.low;
|
|
|
336 return w0.ll;
|
|
|
337 }
|
|
|
338 }
|
|
|
339 else
|
|
|
340 {
|
|
|
341 /* A few sign checks and a single multiplication. */
|
|
|
342 if (uu.s.high >= 0)
|
|
|
343 {
|
|
|
344 if (vv.s.high >= 0)
|
|
|
345 {
|
|
|
346 if (uu.s.high == 0 && vv.s.high == 0)
|
|
|
347 {
|
|
|
348 const DWtype w = (UDWtype) (UWtype) uu.s.low
|
|
|
349 * (UDWtype) (UWtype) vv.s.low;
|
|
|
350 if (__builtin_expect (w >= 0, 1))
|
|
|
351 return w;
|
|
|
352 }
|
|
|
353 }
|
|
|
354 else
|
|
|
355 {
|
|
|
356 if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
|
|
|
357 {
|
|
|
358 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
359 * (UDWtype) (UWtype) vv.s.low};
|
|
|
360
|
|
|
361 ww.s.high -= uu.s.low;
|
|
|
362 if (__builtin_expect (ww.s.high < 0, 1))
|
|
|
363 return ww.ll;
|
|
|
364 }
|
|
|
365 }
|
|
|
366 }
|
|
|
367 else
|
|
|
368 {
|
|
|
369 if (vv.s.high >= 0)
|
|
|
370 {
|
|
|
371 if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
|
|
|
372 {
|
|
|
373 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
374 * (UDWtype) (UWtype) vv.s.low};
|
|
|
375
|
|
|
376 ww.s.high -= vv.s.low;
|
|
|
377 if (__builtin_expect (ww.s.high < 0, 1))
|
|
|
378 return ww.ll;
|
|
|
379 }
|
|
|
380 }
|
|
|
381 else
|
|
|
382 {
|
|
|
383 if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1)
|
|
|
384 {
|
|
|
385 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
|
|
|
386 * (UDWtype) (UWtype) vv.s.low};
|
|
|
387
|
|
|
388 ww.s.high -= uu.s.low;
|
|
|
389 ww.s.high -= vv.s.low;
|
|
|
390 if (__builtin_expect (ww.s.high >= 0, 1))
|
|
|
391 return ww.ll;
|
|
|
392 }
|
|
|
393 }
|
|
|
394 }
|
|
|
395 }
|
|
|
396 }
|
|
|
397
|
|
|
398 /* Overflow. */
|
|
|
399 abort ();
|
|
|
400 }
|
|
|
401 #endif
|
|
|
402
|
|
|
403
|
|
|
404 /* Unless shift functions are defined with full ANSI prototypes,
|
|
|
405 parameter b will be promoted to int if shift_count_type is smaller than an int. */
|
|
|
406 #ifdef L_lshrdi3
|
|
|
407 DWtype
|
|
|
408 __lshrdi3 (DWtype u, shift_count_type b)
|
|
|
409 {
|
|
|
410 if (b == 0)
|
|
|
411 return u;
|
|
|
412
|
|
|
413 const DWunion uu = {.ll = u};
|
|
|
414 const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
|
|
415 DWunion w;
|
|
|
416
|
|
|
417 if (bm <= 0)
|
|
|
418 {
|
|
|
419 w.s.high = 0;
|
|
|
420 w.s.low = (UWtype) uu.s.high >> -bm;
|
|
|
421 }
|
|
|
422 else
|
|
|
423 {
|
|
|
424 const UWtype carries = (UWtype) uu.s.high << bm;
|
|
|
425
|
|
|
426 w.s.high = (UWtype) uu.s.high >> b;
|
|
|
427 w.s.low = ((UWtype) uu.s.low >> b) | carries;
|
|
|
428 }
|
|
|
429
|
|
|
430 return w.ll;
|
|
|
431 }
|
|
|
432 #endif
|
|
|
433
|
|
|
434 #ifdef L_ashldi3
|
|
|
435 DWtype
|
|
|
436 __ashldi3 (DWtype u, shift_count_type b)
|
|
|
437 {
|
|
|
438 if (b == 0)
|
|
|
439 return u;
|
|
|
440
|
|
|
441 const DWunion uu = {.ll = u};
|
|
|
442 const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
|
|
443 DWunion w;
|
|
|
444
|
|
|
445 if (bm <= 0)
|
|
|
446 {
|
|
|
447 w.s.low = 0;
|
|
|
448 w.s.high = (UWtype) uu.s.low << -bm;
|
|
|
449 }
|
|
|
450 else
|
|
|
451 {
|
|
|
452 const UWtype carries = (UWtype) uu.s.low >> bm;
|
|
|
453
|
|
|
454 w.s.low = (UWtype) uu.s.low << b;
|
|
|
455 w.s.high = ((UWtype) uu.s.high << b) | carries;
|
|
|
456 }
|
|
|
457
|
|
|
458 return w.ll;
|
|
|
459 }
|
|
|
460 #endif
|
|
|
461
|
|
|
462 #ifdef L_ashrdi3
|
|
|
463 DWtype
|
|
|
464 __ashrdi3 (DWtype u, shift_count_type b)
|
|
|
465 {
|
|
|
466 if (b == 0)
|
|
|
467 return u;
|
|
|
468
|
|
|
469 const DWunion uu = {.ll = u};
|
|
|
470 const shift_count_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
|
|
|
471 DWunion w;
|
|
|
472
|
|
|
473 if (bm <= 0)
|
|
|
474 {
|
|
|
475 /* w.s.high = 1..1 or 0..0 */
|
|
|
476 w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
|
|
|
477 w.s.low = uu.s.high >> -bm;
|
|
|
478 }
|
|
|
479 else
|
|
|
480 {
|
|
|
481 const UWtype carries = (UWtype) uu.s.high << bm;
|
|
|
482
|
|
|
483 w.s.high = uu.s.high >> b;
|
|
|
484 w.s.low = ((UWtype) uu.s.low >> b) | carries;
|
|
|
485 }
|
|
|
486
|
|
|
487 return w.ll;
|
|
|
488 }
|
|
|
489 #endif
|
|
|
490
|
|
|
491 #ifdef L_bswapsi2
|
|
|
492 SItype
|
|
|
493 __bswapsi2 (SItype u)
|
|
|
494 {
|
|
|
495 return ((((u) & 0xff000000) >> 24)
|
|
|
496 | (((u) & 0x00ff0000) >> 8)
|
|
|
497 | (((u) & 0x0000ff00) << 8)
|
|
|
498 | (((u) & 0x000000ff) << 24));
|
|
|
499 }
|
|
|
500 #endif
|
|
|
501 #ifdef L_bswapdi2
|
|
|
502 DItype
|
|
|
503 __bswapdi2 (DItype u)
|
|
|
504 {
|
|
|
505 return ((((u) & 0xff00000000000000ull) >> 56)
|
|
|
506 | (((u) & 0x00ff000000000000ull) >> 40)
|
|
|
507 | (((u) & 0x0000ff0000000000ull) >> 24)
|
|
|
508 | (((u) & 0x000000ff00000000ull) >> 8)
|
|
|
509 | (((u) & 0x00000000ff000000ull) << 8)
|
|
|
510 | (((u) & 0x0000000000ff0000ull) << 24)
|
|
|
511 | (((u) & 0x000000000000ff00ull) << 40)
|
|
|
512 | (((u) & 0x00000000000000ffull) << 56));
|
|
|
513 }
|
|
|
514 #endif
|
|
|
515 #ifdef L_ffssi2
|
|
|
516 #undef int
|
|
|
517 int
|
|
|
518 __ffsSI2 (UWtype u)
|
|
|
519 {
|
|
|
520 UWtype count;
|
|
|
521
|
|
|
522 if (u == 0)
|
|
|
523 return 0;
|
|
|
524
|
|
|
525 count_trailing_zeros (count, u);
|
|
|
526 return count + 1;
|
|
|
527 }
|
|
|
528 #endif
|
|
|
529
|
|
|
530 #ifdef L_ffsdi2
|
|
|
531 #undef int
|
|
|
532 int
|
|
|
533 __ffsDI2 (DWtype u)
|
|
|
534 {
|
|
|
535 const DWunion uu = {.ll = u};
|
|
|
536 UWtype word, count, add;
|
|
|
537
|
|
|
538 if (uu.s.low != 0)
|
|
|
539 word = uu.s.low, add = 0;
|
|
|
540 else if (uu.s.high != 0)
|
|
|
541 word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
|
|
|
542 else
|
|
|
543 return 0;
|
|
|
544
|
|
|
545 count_trailing_zeros (count, word);
|
|
|
546 return count + add + 1;
|
|
|
547 }
|
|
|
548 #endif
|
|
|
549
|
|
|
550 #ifdef L_muldi3
|
|
|
551 DWtype
|
|
|
552 __muldi3 (DWtype u, DWtype v)
|
|
|
553 {
|
|
|
554 const DWunion uu = {.ll = u};
|
|
|
555 const DWunion vv = {.ll = v};
|
|
|
556 DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
|
|
|
557
|
|
|
558 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
|
|
|
559 + (UWtype) uu.s.high * (UWtype) vv.s.low);
|
|
|
560
|
|
|
561 return w.ll;
|
|
|
562 }
|
|
|
563 #endif
|
|
|
564
|
|
|
565 #if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
566 defined (L_umoddi3) || defined (L_moddi3))
|
|
|
567 #if defined (sdiv_qrnnd)
|
|
|
568 #define L_udiv_w_sdiv
|
|
|
569 #endif
|
|
|
570 #endif
|
|
|
571
|
|
|
572 #ifdef L_udiv_w_sdiv
|
|
|
573 #if defined (sdiv_qrnnd)
|
|
|
574 #if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
575 defined (L_umoddi3) || defined (L_moddi3))
|
|
|
576 static inline __attribute__ ((__always_inline__))
|
|
|
577 #endif
|
|
|
578 UWtype
|
|
|
579 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
|
|
|
580 {
|
|
|
581 UWtype q, r;
|
|
|
582 UWtype c0, c1, b1;
|
|
|
583
|
|
|
584 if ((Wtype) d >= 0)
|
|
|
585 {
|
|
|
586 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
|
|
|
587 {
|
|
|
588 /* Dividend, divisor, and quotient are nonnegative. */
|
|
|
589 sdiv_qrnnd (q, r, a1, a0, d);
|
|
|
590 }
|
|
|
591 else
|
|
|
592 {
|
|
|
593 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
|
|
|
594 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
|
|
|
595 /* Divide (c1*2^32 + c0) by d. */
|
|
|
596 sdiv_qrnnd (q, r, c1, c0, d);
|
|
|
597 /* Add 2^31 to quotient. */
|
|
|
598 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
|
|
|
599 }
|
|
|
600 }
|
|
|
601 else
|
|
|
602 {
|
|
|
603 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
|
|
|
604 c1 = a1 >> 1; /* A/2 */
|
|
|
605 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
|
|
|
606
|
|
|
607 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
|
|
|
608 {
|
|
|
609 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
|
|
|
610
|
|
|
611 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
|
|
|
612 if ((d & 1) != 0)
|
|
|
613 {
|
|
|
614 if (r >= q)
|
|
|
615 r = r - q;
|
|
|
616 else if (q - r <= d)
|
|
|
617 {
|
|
|
618 r = r - q + d;
|
|
|
619 q--;
|
|
|
620 }
|
|
|
621 else
|
|
|
622 {
|
|
|
623 r = r - q + 2*d;
|
|
|
624 q -= 2;
|
|
|
625 }
|
|
|
626 }
|
|
|
627 }
|
|
|
628 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
|
|
|
629 {
|
|
|
630 c1 = (b1 - 1) - c1;
|
|
|
631 c0 = ~c0; /* logical NOT */
|
|
|
632
|
|
|
633 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
|
|
|
634
|
|
|
635 q = ~q; /* (A/2)/b1 */
|
|
|
636 r = (b1 - 1) - r;
|
|
|
637
|
|
|
638 r = 2*r + (a0 & 1); /* A/(2*b1) */
|
|
|
639
|
|
|
640 if ((d & 1) != 0)
|
|
|
641 {
|
|
|
642 if (r >= q)
|
|
|
643 r = r - q;
|
|
|
644 else if (q - r <= d)
|
|
|
645 {
|
|
|
646 r = r - q + d;
|
|
|
647 q--;
|
|
|
648 }
|
|
|
649 else
|
|
|
650 {
|
|
|
651 r = r - q + 2*d;
|
|
|
652 q -= 2;
|
|
|
653 }
|
|
|
654 }
|
|
|
655 }
|
|
|
656 else /* Implies c1 = b1 */
|
|
|
657 { /* Hence a1 = d - 1 = 2*b1 - 1 */
|
|
|
658 if (a0 >= -d)
|
|
|
659 {
|
|
|
660 q = -1;
|
|
|
661 r = a0 + d;
|
|
|
662 }
|
|
|
663 else
|
|
|
664 {
|
|
|
665 q = -2;
|
|
|
666 r = a0 + 2*d;
|
|
|
667 }
|
|
|
668 }
|
|
|
669 }
|
|
|
670
|
|
|
671 *rp = r;
|
|
|
672 return q;
|
|
|
673 }
|
|
|
674 #else
|
|
|
675 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
|
|
|
676 UWtype
|
|
|
677 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
|
|
|
678 UWtype a1 __attribute__ ((__unused__)),
|
|
|
679 UWtype a0 __attribute__ ((__unused__)),
|
|
|
680 UWtype d __attribute__ ((__unused__)))
|
|
|
681 {
|
|
|
682 return 0;
|
|
|
683 }
|
|
|
684 #endif
|
|
|
685 #endif
|
|
|
686
|
|
|
687 #if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
688 defined (L_umoddi3) || defined (L_moddi3))
|
|
|
689 #define L_udivmoddi4
|
|
|
690 #endif
|
|
|
691
|
|
|
692 #ifdef L_clz
|
|
|
693 const UQItype __clz_tab[256] =
|
|
|
694 {
|
|
|
695 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
|
|
696 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
|
|
697 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
|
698 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
|
699 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
700 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
701 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
|
702 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
|
|
|
703 };
|
|
|
704 #endif
|
|
|
705
|
|
|
706 #ifdef L_clzsi2
|
|
|
707 #undef int
|
|
|
708 int
|
|
|
709 __clzSI2 (UWtype x)
|
|
|
710 {
|
|
|
711 Wtype ret;
|
|
|
712
|
|
|
713 count_leading_zeros (ret, x);
|
|
|
714
|
|
|
715 return ret;
|
|
|
716 }
|
|
|
717 #endif
|
|
|
718
|
|
|
719 #ifdef L_clzdi2
|
|
|
720 #undef int
|
|
|
721 int
|
|
|
722 __clzDI2 (UDWtype x)
|
|
|
723 {
|
|
|
724 const DWunion uu = {.ll = x};
|
|
|
725 UWtype word;
|
|
|
726 Wtype ret, add;
|
|
|
727
|
|
|
728 if (uu.s.high)
|
|
|
729 word = uu.s.high, add = 0;
|
|
|
730 else
|
|
|
731 word = uu.s.low, add = W_TYPE_SIZE;
|
|
|
732
|
|
|
733 count_leading_zeros (ret, word);
|
|
|
734 return ret + add;
|
|
|
735 }
|
|
|
736 #endif
|
|
|
737
|
|
|
738 #ifdef L_ctzsi2
|
|
|
739 #undef int
|
|
|
740 int
|
|
|
741 __ctzSI2 (UWtype x)
|
|
|
742 {
|
|
|
743 Wtype ret;
|
|
|
744
|
|
|
745 count_trailing_zeros (ret, x);
|
|
|
746
|
|
|
747 return ret;
|
|
|
748 }
|
|
|
749 #endif
|
|
|
750
|
|
|
751 #ifdef L_ctzdi2
|
|
|
752 #undef int
|
|
|
753 int
|
|
|
754 __ctzDI2 (UDWtype x)
|
|
|
755 {
|
|
|
756 const DWunion uu = {.ll = x};
|
|
|
757 UWtype word;
|
|
|
758 Wtype ret, add;
|
|
|
759
|
|
|
760 if (uu.s.low)
|
|
|
761 word = uu.s.low, add = 0;
|
|
|
762 else
|
|
|
763 word = uu.s.high, add = W_TYPE_SIZE;
|
|
|
764
|
|
|
765 count_trailing_zeros (ret, word);
|
|
|
766 return ret + add;
|
|
|
767 }
|
|
|
768 #endif
|
|
|
769
|
|
|
770 #ifdef L_popcount_tab
|
|
|
771 const UQItype __popcount_tab[256] =
|
|
|
772 {
|
|
|
773 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
|
|
|
774 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
|
|
|
775 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
|
|
|
776 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
|
|
|
777 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
|
|
|
778 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
|
|
|
779 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
|
|
|
780 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
|
|
|
781 };
|
|
|
782 #endif
|
|
|
783
|
|
|
784 #ifdef L_popcountsi2
|
|
|
785 #undef int
|
|
|
786 int
|
|
|
787 __popcountSI2 (UWtype x)
|
|
|
788 {
|
|
|
789 int i, ret = 0;
|
|
|
790
|
|
|
791 for (i = 0; i < W_TYPE_SIZE; i += 8)
|
|
|
792 ret += __popcount_tab[(x >> i) & 0xff];
|
|
|
793
|
|
|
794 return ret;
|
|
|
795 }
|
|
|
796 #endif
|
|
|
797
|
|
|
798 #ifdef L_popcountdi2
|
|
|
799 #undef int
|
|
|
800 int
|
|
|
801 __popcountDI2 (UDWtype x)
|
|
|
802 {
|
|
|
803 int i, ret = 0;
|
|
|
804
|
|
|
805 for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
|
|
|
806 ret += __popcount_tab[(x >> i) & 0xff];
|
|
|
807
|
|
|
808 return ret;
|
|
|
809 }
|
|
|
810 #endif
|
|
|
811
|
|
|
812 #ifdef L_paritysi2
|
|
|
813 #undef int
|
|
|
814 int
|
|
|
815 __paritySI2 (UWtype x)
|
|
|
816 {
|
|
|
817 #if W_TYPE_SIZE > 64
|
|
|
818 # error "fill out the table"
|
|
|
819 #endif
|
|
|
820 #if W_TYPE_SIZE > 32
|
|
|
821 x ^= x >> 32;
|
|
|
822 #endif
|
|
|
823 #if W_TYPE_SIZE > 16
|
|
|
824 x ^= x >> 16;
|
|
|
825 #endif
|
|
|
826 x ^= x >> 8;
|
|
|
827 x ^= x >> 4;
|
|
|
828 x &= 0xf;
|
|
|
829 return (0x6996 >> x) & 1;
|
|
|
830 }
|
|
|
831 #endif
|
|
|
832
|
|
|
833 #ifdef L_paritydi2
|
|
|
834 #undef int
|
|
|
835 int
|
|
|
836 __parityDI2 (UDWtype x)
|
|
|
837 {
|
|
|
838 const DWunion uu = {.ll = x};
|
|
|
839 UWtype nx = uu.s.low ^ uu.s.high;
|
|
|
840
|
|
|
841 #if W_TYPE_SIZE > 64
|
|
|
842 # error "fill out the table"
|
|
|
843 #endif
|
|
|
844 #if W_TYPE_SIZE > 32
|
|
|
845 nx ^= nx >> 32;
|
|
|
846 #endif
|
|
|
847 #if W_TYPE_SIZE > 16
|
|
|
848 nx ^= nx >> 16;
|
|
|
849 #endif
|
|
|
850 nx ^= nx >> 8;
|
|
|
851 nx ^= nx >> 4;
|
|
|
852 nx &= 0xf;
|
|
|
853 return (0x6996 >> nx) & 1;
|
|
|
854 }
|
|
|
855 #endif
|
|
|
856
|
|
|
857 #ifdef L_udivmoddi4
|
|
|
858
|
|
|
859 #if (defined (L_udivdi3) || defined (L_divdi3) || \
|
|
|
860 defined (L_umoddi3) || defined (L_moddi3))
|
|
|
861 static inline __attribute__ ((__always_inline__))
|
|
|
862 #endif
|
|
|
863 UDWtype
|
|
|
864 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
|
|
|
865 {
|
|
|
866 const DWunion nn = {.ll = n};
|
|
|
867 const DWunion dd = {.ll = d};
|
|
|
868 DWunion rr;
|
|
|
869 UWtype d0, d1, n0, n1, n2;
|
|
|
870 UWtype q0, q1;
|
|
|
871 UWtype b, bm;
|
|
|
872
|
|
|
873 d0 = dd.s.low;
|
|
|
874 d1 = dd.s.high;
|
|
|
875 n0 = nn.s.low;
|
|
|
876 n1 = nn.s.high;
|
|
|
877
|
|
|
878 #if !UDIV_NEEDS_NORMALIZATION
|
|
|
879 if (d1 == 0)
|
|
|
880 {
|
|
|
881 if (d0 > n1)
|
|
|
882 {
|
|
|
883 /* 0q = nn / 0D */
|
|
|
884
|
|
|
885 udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
886 q1 = 0;
|
|
|
887
|
|
|
888 /* Remainder in n0. */
|
|
|
889 }
|
|
|
890 else
|
|
|
891 {
|
|
|
892 /* qq = NN / 0d */
|
|
|
893
|
|
|
894 if (d0 == 0)
|
|
|
895 d0 = 1 / d0; /* Divide intentionally by zero. */
|
|
|
896
|
|
|
897 udiv_qrnnd (q1, n1, 0, n1, d0);
|
|
|
898 udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
899
|
|
|
900 /* Remainder in n0. */
|
|
|
901 }
|
|
|
902
|
|
|
903 if (rp != 0)
|
|
|
904 {
|
|
|
905 rr.s.low = n0;
|
|
|
906 rr.s.high = 0;
|
|
|
907 *rp = rr.ll;
|
|
|
908 }
|
|
|
909 }
|
|
|
910
|
|
|
911 #else /* UDIV_NEEDS_NORMALIZATION */
|
|
|
912
|
|
|
913 if (d1 == 0)
|
|
|
914 {
|
|
|
915 if (d0 > n1)
|
|
|
916 {
|
|
|
917 /* 0q = nn / 0D */
|
|
|
918
|
|
|
919 count_leading_zeros (bm, d0);
|
|
|
920
|
|
|
921 if (bm != 0)
|
|
|
922 {
|
|
|
923 /* Normalize, i.e. make the most significant bit of the
|
|
|
924 denominator set. */
|
|
|
925
|
|
|
926 d0 = d0 << bm;
|
|
|
927 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
|
|
|
928 n0 = n0 << bm;
|
|
|
929 }
|
|
|
930
|
|
|
931 udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
932 q1 = 0;
|
|
|
933
|
|
|
934 /* Remainder in n0 >> bm. */
|
|
|
935 }
|
|
|
936 else
|
|
|
937 {
|
|
|
938 /* qq = NN / 0d */
|
|
|
939
|
|
|
940 if (d0 == 0)
|
|
|
941 d0 = 1 / d0; /* Divide intentionally by zero. */
|
|
|
942
|
|
|
943 count_leading_zeros (bm, d0);
|
|
|
944
|
|
|
945 if (bm == 0)
|
|
|
946 {
|
|
|
947 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
|
|
|
948 conclude (the most significant bit of n1 is set) /\ (the
|
|
|
949 leading quotient digit q1 = 1).
|
|
|
950
|
|
|
951 This special case is necessary, not an optimization.
|
|
|
952 (Shifts counts of W_TYPE_SIZE are undefined.) */
|
|
|
953
|
|
|
954 n1 -= d0;
|
|
|
955 q1 = 1;
|
|
|
956 }
|
|
|
957 else
|
|
|
958 {
|
|
|
959 /* Normalize. */
|
|
|
960
|
|
|
961 b = W_TYPE_SIZE - bm;
|
|
|
962
|
|
|
963 d0 = d0 << bm;
|
|
|
964 n2 = n1 >> b;
|
|
|
965 n1 = (n1 << bm) | (n0 >> b);
|
|
|
966 n0 = n0 << bm;
|
|
|
967
|
|
|
968 udiv_qrnnd (q1, n1, n2, n1, d0);
|
|
|
969 }
|
|
|
970
|
|
|
971 /* n1 != d0... */
|
|
|
972
|
|
|
973 udiv_qrnnd (q0, n0, n1, n0, d0);
|
|
|
974
|
|
|
975 /* Remainder in n0 >> bm. */
|
|
|
976 }
|
|
|
977
|
|
|
978 if (rp != 0)
|
|
|
979 {
|
|
|
980 rr.s.low = n0 >> bm;
|
|
|
981 rr.s.high = 0;
|
|
|
982 *rp = rr.ll;
|
|
|
983 }
|
|
|
984 }
|
|
|
985 #endif /* UDIV_NEEDS_NORMALIZATION */
|
|
|
986
|
|
|
987 else
|
|
|
988 {
|
|
|
989 if (d1 > n1)
|
|
|
990 {
|
|
|
991 /* 00 = nn / DD */
|
|
|
992
|
|
|
993 q0 = 0;
|
|
|
994 q1 = 0;
|
|
|
995
|
|
|
996 /* Remainder in n1n0. */
|
|
|
997 if (rp != 0)
|
|
|
998 {
|
|
|
999 rr.s.low = n0;
|
|
|
1000 rr.s.high = n1;
|
|
|
1001 *rp = rr.ll;
|
|
|
1002 }
|
|
|
1003 }
|
|
|
1004 else
|
|
|
1005 {
|
|
|
1006 /* 0q = NN / dd */
|
|
|
1007
|
|
|
1008 count_leading_zeros (bm, d1);
|
|
|
1009 if (bm == 0)
|
|
|
1010 {
|
|
|
1011 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
|
|
|
1012 conclude (the most significant bit of n1 is set) /\ (the
|
|
|
1013 quotient digit q0 = 0 or 1).
|
|
|
1014
|
|
|
1015 This special case is necessary, not an optimization. */
|
|
|
1016
|
|
|
1017 /* The condition on the next line takes advantage of that
|
|
|
1018 n1 >= d1 (true due to program flow). */
|
|
|
1019 if (n1 > d1 || n0 >= d0)
|
|
|
1020 {
|
|
|
1021 q0 = 1;
|
|
|
1022 sub_ddmmss (n1, n0, n1, n0, d1, d0);
|
|
|
1023 }
|
|
|
1024 else
|
|
|
1025 q0 = 0;
|
|
|
1026
|
|
|
1027 q1 = 0;
|
|
|
1028
|
|
|
1029 if (rp != 0)
|
|
|
1030 {
|
|
|
1031 rr.s.low = n0;
|
|
|
1032 rr.s.high = n1;
|
|
|
1033 *rp = rr.ll;
|
|
|
1034 }
|
|
|
1035 }
|
|
|
1036 else
|
|
|
1037 {
|
|
|
1038 UWtype m1, m0;
|
|
|
1039 /* Normalize. */
|
|
|
1040
|
|
|
1041 b = W_TYPE_SIZE - bm;
|
|
|
1042
|
|
|
1043 d1 = (d1 << bm) | (d0 >> b);
|
|
|
1044 d0 = d0 << bm;
|
|
|
1045 n2 = n1 >> b;
|
|
|
1046 n1 = (n1 << bm) | (n0 >> b);
|
|
|
1047 n0 = n0 << bm;
|
|
|
1048
|
|
|
1049 udiv_qrnnd (q0, n1, n2, n1, d1);
|
|
|
1050 umul_ppmm (m1, m0, q0, d0);
|
|
|
1051
|
|
|
1052 if (m1 > n1 || (m1 == n1 && m0 > n0))
|
|
|
1053 {
|
|
|
1054 q0--;
|
|
|
1055 sub_ddmmss (m1, m0, m1, m0, d1, d0);
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 q1 = 0;
|
|
|
1059
|
|
|
1060 /* Remainder in (n1n0 - m1m0) >> bm. */
|
|
|
1061 if (rp != 0)
|
|
|
1062 {
|
|
|
1063 sub_ddmmss (n1, n0, n1, n0, m1, m0);
|
|
|
1064 rr.s.low = (n1 << b) | (n0 >> bm);
|
|
|
1065 rr.s.high = n1 >> bm;
|
|
|
1066 *rp = rr.ll;
|
|
|
1067 }
|
|
|
1068 }
|
|
|
1069 }
|
|
|
1070 }
|
|
|
1071
|
|
|
1072 const DWunion ww = {{.low = q0, .high = q1}};
|
|
|
1073 return ww.ll;
|
|
|
1074 }
|
|
|
1075 #endif
|
|
|
1076
|
|
|
1077 #ifdef L_divdi3
|
|
|
1078 DWtype
|
|
|
1079 __divdi3 (DWtype u, DWtype v)
|
|
|
1080 {
|
|
|
1081 Wtype c = 0;
|
|
|
1082 DWunion uu = {.ll = u};
|
|
|
1083 DWunion vv = {.ll = v};
|
|
|
1084 DWtype w;
|
|
|
1085
|
|
|
1086 if (uu.s.high < 0)
|
|
|
1087 c = ~c,
|
|
|
1088 uu.ll = -uu.ll;
|
|
|
1089 if (vv.s.high < 0)
|
|
|
1090 c = ~c,
|
|
|
1091 vv.ll = -vv.ll;
|
|
|
1092
|
|
|
1093 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
|
|
|
1094 if (c)
|
|
|
1095 w = -w;
|
|
|
1096
|
|
|
1097 return w;
|
|
|
1098 }
|
|
|
1099 #endif
|
|
|
1100
|
|
|
1101 #ifdef L_moddi3
|
|
|
1102 DWtype
|
|
|
1103 __moddi3 (DWtype u, DWtype v)
|
|
|
1104 {
|
|
|
1105 Wtype c = 0;
|
|
|
1106 DWunion uu = {.ll = u};
|
|
|
1107 DWunion vv = {.ll = v};
|
|
|
1108 DWtype w;
|
|
|
1109
|
|
|
1110 if (uu.s.high < 0)
|
|
|
1111 c = ~c,
|
|
|
1112 uu.ll = -uu.ll;
|
|
|
1113 if (vv.s.high < 0)
|
|
|
1114 vv.ll = -vv.ll;
|
|
|
1115
|
|
|
1116 (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
|
|
|
1117 if (c)
|
|
|
1118 w = -w;
|
|
|
1119
|
|
|
1120 return w;
|
|
|
1121 }
|
|
|
1122 #endif
|
|
|
1123
|
|
|
1124 #ifdef L_umoddi3
|
|
|
1125 UDWtype
|
|
|
1126 __umoddi3 (UDWtype u, UDWtype v)
|
|
|
1127 {
|
|
|
1128 UDWtype w;
|
|
|
1129
|
|
|
1130 (void) __udivmoddi4 (u, v, &w);
|
|
|
1131
|
|
|
1132 return w;
|
|
|
1133 }
|
|
|
1134 #endif
|
|
|
1135
|
|
|
1136 #ifdef L_udivdi3
|
|
|
1137 UDWtype
|
|
|
1138 __udivdi3 (UDWtype n, UDWtype d)
|
|
|
1139 {
|
|
|
1140 return __udivmoddi4 (n, d, (UDWtype *) 0);
|
|
|
1141 }
|
|
|
1142 #endif
|
|
|
1143
|
|
|
1144 #ifdef L_cmpdi2
|
|
|
1145 cmp_return_type
|
|
|
1146 __cmpdi2 (DWtype a, DWtype b)
|
|
|
1147 {
|
|
|
1148 const DWunion au = {.ll = a};
|
|
|
1149 const DWunion bu = {.ll = b};
|
|
|
1150
|
|
|
1151 if (au.s.high < bu.s.high)
|
|
|
1152 return 0;
|
|
|
1153 else if (au.s.high > bu.s.high)
|
|
|
1154 return 2;
|
|
|
1155 if ((UWtype) au.s.low < (UWtype) bu.s.low)
|
|
|
1156 return 0;
|
|
|
1157 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
|
|
|
1158 return 2;
|
|
|
1159 return 1;
|
|
|
1160 }
|
|
|
1161 #endif
|
|
|
1162
|
|
|
1163 #ifdef L_ucmpdi2
|
|
|
1164 cmp_return_type
|
|
|
1165 __ucmpdi2 (DWtype a, DWtype b)
|
|
|
1166 {
|
|
|
1167 const DWunion au = {.ll = a};
|
|
|
1168 const DWunion bu = {.ll = b};
|
|
|
1169
|
|
|
1170 if ((UWtype) au.s.high < (UWtype) bu.s.high)
|
|
|
1171 return 0;
|
|
|
1172 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
|
|
|
1173 return 2;
|
|
|
1174 if ((UWtype) au.s.low < (UWtype) bu.s.low)
|
|
|
1175 return 0;
|
|
|
1176 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
|
|
|
1177 return 2;
|
|
|
1178 return 1;
|
|
|
1179 }
|
|
|
1180 #endif
|
|
|
1181
|
|
|
1182 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
|
|
|
1183 UDWtype
|
|
|
1184 __fixunstfDI (TFtype a)
|
|
|
1185 {
|
|
|
1186 if (a < 0)
|
|
|
1187 return 0;
|
|
|
1188
|
|
|
1189 /* Compute high word of result, as a flonum. */
|
|
|
1190 const TFtype b = (a / Wtype_MAXp1_F);
|
|
|
1191 /* Convert that to fixed (but not to DWtype!),
|
|
|
1192 and shift it into the high word. */
|
|
|
1193 UDWtype v = (UWtype) b;
|
|
|
1194 v <<= W_TYPE_SIZE;
|
|
|
1195 /* Remove high part from the TFtype, leaving the low part as flonum. */
|
|
|
1196 a -= (TFtype)v;
|
|
|
1197 /* Convert that to fixed (but not to DWtype!) and add it in.
|
|
|
1198 Sometimes A comes out negative. This is significant, since
|
|
|
1199 A has more bits than a long int does. */
|
|
|
1200 if (a < 0)
|
|
|
1201 v -= (UWtype) (- a);
|
|
|
1202 else
|
|
|
1203 v += (UWtype) a;
|
|
|
1204 return v;
|
|
|
1205 }
|
|
|
1206 #endif
|
|
|
1207
|
|
|
1208 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
|
|
|
1209 DWtype
|
|
|
1210 __fixtfdi (TFtype a)
|
|
|
1211 {
|
|
|
1212 if (a < 0)
|
|
|
1213 return - __fixunstfDI (-a);
|
|
|
1214 return __fixunstfDI (a);
|
|
|
1215 }
|
|
|
1216 #endif
|
|
|
1217
|
|
|
1218 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
|
|
|
1219 UDWtype
|
|
|
1220 __fixunsxfDI (XFtype a)
|
|
|
1221 {
|
|
|
1222 if (a < 0)
|
|
|
1223 return 0;
|
|
|
1224
|
|
|
1225 /* Compute high word of result, as a flonum. */
|
|
|
1226 const XFtype b = (a / Wtype_MAXp1_F);
|
|
|
1227 /* Convert that to fixed (but not to DWtype!),
|
|
|
1228 and shift it into the high word. */
|
|
|
1229 UDWtype v = (UWtype) b;
|
|
|
1230 v <<= W_TYPE_SIZE;
|
|
|
1231 /* Remove high part from the XFtype, leaving the low part as flonum. */
|
|
|
1232 a -= (XFtype)v;
|
|
|
1233 /* Convert that to fixed (but not to DWtype!) and add it in.
|
|
|
1234 Sometimes A comes out negative. This is significant, since
|
|
|
1235 A has more bits than a long int does. */
|
|
|
1236 if (a < 0)
|
|
|
1237 v -= (UWtype) (- a);
|
|
|
1238 else
|
|
|
1239 v += (UWtype) a;
|
|
|
1240 return v;
|
|
|
1241 }
|
|
|
1242 #endif
|
|
|
1243
|
|
|
1244 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
|
|
|
1245 DWtype
|
|
|
1246 __fixxfdi (XFtype a)
|
|
|
1247 {
|
|
|
1248 if (a < 0)
|
|
|
1249 return - __fixunsxfDI (-a);
|
|
|
1250 return __fixunsxfDI (a);
|
|
|
1251 }
|
|
|
1252 #endif
|
|
|
1253
|
|
|
1254 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
|
|
|
1255 UDWtype
|
|
|
1256 __fixunsdfDI (DFtype a)
|
|
|
1257 {
|
|
|
1258 /* Get high part of result. The division here will just moves the radix
|
|
|
1259 point and will not cause any rounding. Then the conversion to integral
|
|
|
1260 type chops result as desired. */
|
|
|
1261 const UWtype hi = a / Wtype_MAXp1_F;
|
|
|
1262
|
|
|
1263 /* Get low part of result. Convert `hi' to floating type and scale it back,
|
|
|
1264 then subtract this from the number being converted. This leaves the low
|
|
|
1265 part. Convert that to integral type. */
|
|
|
1266 const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
|
|
|
1267
|
|
|
1268 /* Assemble result from the two parts. */
|
|
|
1269 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
|
|
|
1270 }
|
|
|
1271 #endif
|
|
|
1272
|
|
|
1273 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
|
|
|
1274 DWtype
|
|
|
1275 __fixdfdi (DFtype a)
|
|
|
1276 {
|
|
|
1277 if (a < 0)
|
|
|
1278 return - __fixunsdfDI (-a);
|
|
|
1279 return __fixunsdfDI (a);
|
|
|
1280 }
|
|
|
1281 #endif
|
|
|
1282
|
|
|
1283 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
|
|
|
1284 UDWtype
|
|
|
1285 __fixunssfDI (SFtype a)
|
|
|
1286 {
|
|
|
1287 #if LIBGCC2_HAS_DF_MODE
|
|
|
1288 /* Convert the SFtype to a DFtype, because that is surely not going
|
|
|
1289 to lose any bits. Some day someone else can write a faster version
|
|
|
1290 that avoids converting to DFtype, and verify it really works right. */
|
|
|
1291 const DFtype dfa = a;
|
|
|
1292
|
|
|
1293 /* Get high part of result. The division here will just moves the radix
|
|
|
1294 point and will not cause any rounding. Then the conversion to integral
|
|
|
1295 type chops result as desired. */
|
|
|
1296 const UWtype hi = dfa / Wtype_MAXp1_F;
|
|
|
1297
|
|
|
1298 /* Get low part of result. Convert `hi' to floating type and scale it back,
|
|
|
1299 then subtract this from the number being converted. This leaves the low
|
|
|
1300 part. Convert that to integral type. */
|
|
|
1301 const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
|
|
|
1302
|
|
|
1303 /* Assemble result from the two parts. */
|
|
|
1304 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
|
|
|
1305 #elif FLT_MANT_DIG < W_TYPE_SIZE
|
|
|
1306 if (a < 1)
|
|
|
1307 return 0;
|
|
|
1308 if (a < Wtype_MAXp1_F)
|
|
|
1309 return (UWtype)a;
|
|
|
1310 if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
|
|
|
1311 {
|
|
|
1312 /* Since we know that there are fewer significant bits in the SFmode
|
|
|
1313 quantity than in a word, we know that we can convert out all the
|
|
|
1314 significant bits in one step, and thus avoid losing bits. */
|
|
|
1315
|
|
|
1316 /* ??? This following loop essentially performs frexpf. If we could
|
|
|
1317 use the real libm function, or poke at the actual bits of the fp
|
|
|
1318 format, it would be significantly faster. */
|
|
|
1319
|
|
|
1320 UWtype shift = 0, counter;
|
|
|
1321 SFtype msb;
|
|
|
1322
|
|
|
1323 a /= Wtype_MAXp1_F;
|
|
|
1324 for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
|
|
|
1325 {
|
|
|
1326 SFtype counterf = (UWtype)1 << counter;
|
|
|
1327 if (a >= counterf)
|
|
|
1328 {
|
|
|
1329 shift |= counter;
|
|
|
1330 a /= counterf;
|
|
|
1331 }
|
|
|
1332 }
|
|
|
1333
|
|
|
1334 /* Rescale into the range of one word, extract the bits of that
|
|
|
1335 one word, and shift the result into position. */
|
|
|
1336 a *= Wtype_MAXp1_F;
|
|
|
1337 counter = a;
|
|
|
1338 return (DWtype)counter << shift;
|
|
|
1339 }
|
|
|
1340 return -1;
|
|
|
1341 #else
|
|
|
1342 # error
|
|
|
1343 #endif
|
|
|
1344 }
|
|
|
1345 #endif
|
|
|
1346
|
|
|
1347 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
|
|
|
1348 DWtype
|
|
|
1349 __fixsfdi (SFtype a)
|
|
|
1350 {
|
|
|
1351 if (a < 0)
|
|
|
1352 return - __fixunssfDI (-a);
|
|
|
1353 return __fixunssfDI (a);
|
|
|
1354 }
|
|
|
1355 #endif
|
|
|
1356
|
|
|
1357 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
|
|
|
1358 XFtype
|
|
|
1359 __floatdixf (DWtype u)
|
|
|
1360 {
|
|
|
1361 #if W_TYPE_SIZE > XF_SIZE
|
|
|
1362 # error
|
|
|
1363 #endif
|
|
|
1364 XFtype d = (Wtype) (u >> W_TYPE_SIZE);
|
|
|
1365 d *= Wtype_MAXp1_F;
|
|
|
1366 d += (UWtype)u;
|
|
|
1367 return d;
|
|
|
1368 }
|
|
|
1369 #endif
|
|
|
1370
|
|
|
1371 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
|
|
|
1372 XFtype
|
|
|
1373 __floatundixf (UDWtype u)
|
|
|
1374 {
|
|
|
1375 #if W_TYPE_SIZE > XF_SIZE
|
|
|
1376 # error
|
|
|
1377 #endif
|
|
|
1378 XFtype d = (UWtype) (u >> W_TYPE_SIZE);
|
|
|
1379 d *= Wtype_MAXp1_F;
|
|
|
1380 d += (UWtype)u;
|
|
|
1381 return d;
|
|
|
1382 }
|
|
|
1383 #endif
|
|
|
1384
|
|
|
1385 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
|
|
|
1386 TFtype
|
|
|
1387 __floatditf (DWtype u)
|
|
|
1388 {
|
|
|
1389 #if W_TYPE_SIZE > TF_SIZE
|
|
|
1390 # error
|
|
|
1391 #endif
|
|
|
1392 TFtype d = (Wtype) (u >> W_TYPE_SIZE);
|
|
|
1393 d *= Wtype_MAXp1_F;
|
|
|
1394 d += (UWtype)u;
|
|
|
1395 return d;
|
|
|
1396 }
|
|
|
1397 #endif
|
|
|
1398
|
|
|
1399 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
|
|
|
1400 TFtype
|
|
|
1401 __floatunditf (UDWtype u)
|
|
|
1402 {
|
|
|
1403 #if W_TYPE_SIZE > TF_SIZE
|
|
|
1404 # error
|
|
|
1405 #endif
|
|
|
1406 TFtype d = (UWtype) (u >> W_TYPE_SIZE);
|
|
|
1407 d *= Wtype_MAXp1_F;
|
|
|
1408 d += (UWtype)u;
|
|
|
1409 return d;
|
|
|
1410 }
|
|
|
1411 #endif
|
|
|
1412
|
|
|
1413 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
|
|
|
1414 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
|
|
|
1415 #define DI_SIZE (W_TYPE_SIZE * 2)
|
|
|
1416 #define F_MODE_OK(SIZE) \
|
|
|
1417 (SIZE < DI_SIZE \
|
|
|
1418 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
|
|
|
1419 && !AVOID_FP_TYPE_CONVERSION(SIZE))
|
|
|
1420 #if defined(L_floatdisf)
|
|
|
1421 #define FUNC __floatdisf
|
|
|
1422 #define FSTYPE SFtype
|
|
|
1423 #define FSSIZE SF_SIZE
|
|
|
1424 #else
|
|
|
1425 #define FUNC __floatdidf
|
|
|
1426 #define FSTYPE DFtype
|
|
|
1427 #define FSSIZE DF_SIZE
|
|
|
1428 #endif
|
|
|
1429
|
|
|
1430 FSTYPE
|
|
|
1431 FUNC (DWtype u)
|
|
|
1432 {
|
|
|
1433 #if FSSIZE >= W_TYPE_SIZE
|
|
|
1434 /* When the word size is small, we never get any rounding error. */
|
|
|
1435 FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
|
|
|
1436 f *= Wtype_MAXp1_F;
|
|
|
1437 f += (UWtype)u;
|
|
|
1438 return f;
|
|
|
1439 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
|
|
|
1440 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
|
|
|
1441 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
|
|
|
1442
|
|
|
1443 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
|
|
|
1444 # define FSIZE DF_SIZE
|
|
|
1445 # define FTYPE DFtype
|
|
|
1446 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
|
|
|
1447 # define FSIZE XF_SIZE
|
|
|
1448 # define FTYPE XFtype
|
|
|
1449 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
|
|
|
1450 # define FSIZE TF_SIZE
|
|
|
1451 # define FTYPE TFtype
|
|
|
1452 #else
|
|
|
1453 # error
|
|
|
1454 #endif
|
|
|
1455
|
|
|
1456 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
|
|
|
1457
|
|
|
1458 /* Protect against double-rounding error.
|
|
|
1459 Represent any low-order bits, that might be truncated by a bit that
|
|
|
1460 won't be lost. The bit can go in anywhere below the rounding position
|
|
|
1461 of the FSTYPE. A fixed mask and bit position handles all usual
|
|
|
1462 configurations. */
|
|
|
1463 if (! (- ((DWtype) 1 << FSIZE) < u
|
|
|
1464 && u < ((DWtype) 1 << FSIZE)))
|
|
|
1465 {
|
|
|
1466 if ((UDWtype) u & (REP_BIT - 1))
|
|
|
1467 {
|
|
|
1468 u &= ~ (REP_BIT - 1);
|
|
|
1469 u |= REP_BIT;
|
|
|
1470 }
|
|
|
1471 }
|
|
|
1472
|
|
|
1473 /* Do the calculation in a wider type so that we don't lose any of
|
|
|
1474 the precision of the high word while multiplying it. */
|
|
|
1475 FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
|
|
|
1476 f *= Wtype_MAXp1_F;
|
|
|
1477 f += (UWtype)u;
|
|
|
1478 return (FSTYPE) f;
|
|
|
1479 #else
|
|
|
1480 #if FSSIZE >= W_TYPE_SIZE - 2
|
|
|
1481 # error
|
|
|
1482 #endif
|
|
|
1483 /* Finally, the word size is larger than the number of bits in the
|
|
|
1484 required FSTYPE, and we've got no suitable wider type. The only
|
|
|
1485 way to avoid double rounding is to special case the
|
|
|
1486 extraction. */
|
|
|
1487
|
|
|
1488 /* If there are no high bits set, fall back to one conversion. */
|
|
|
1489 if ((Wtype)u == u)
|
|
|
1490 return (FSTYPE)(Wtype)u;
|
|
|
1491
|
|
|
1492 /* Otherwise, find the power of two. */
|
|
|
1493 Wtype hi = u >> W_TYPE_SIZE;
|
|
|
1494 if (hi < 0)
|
|
|
1495 hi = -hi;
|
|
|
1496
|
|
|
1497 UWtype count, shift;
|
|
|
1498 count_leading_zeros (count, hi);
|
|
|
1499
|
|
|
1500 /* No leading bits means u == minimum. */
|
|
|
1501 if (count == 0)
|
|
|
1502 return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2));
|
|
|
1503
|
|
|
1504 shift = 1 + W_TYPE_SIZE - count;
|
|
|
1505
|
|
|
1506 /* Shift down the most significant bits. */
|
|
|
1507 hi = u >> shift;
|
|
|
1508
|
|
|
1509 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
|
|
|
1510 if ((UWtype)u << (W_TYPE_SIZE - shift))
|
|
|
1511 hi |= 1;
|
|
|
1512
|
|
|
1513 /* Convert the one word of data, and rescale. */
|
|
|
1514 FSTYPE f = hi, e;
|
|
|
1515 if (shift == W_TYPE_SIZE)
|
|
|
1516 e = Wtype_MAXp1_F;
|
|
|
1517 /* The following two cases could be merged if we knew that the target
|
|
|
1518 supported a native unsigned->float conversion. More often, we only
|
|
|
1519 have a signed conversion, and have to add extra fixup code. */
|
|
|
1520 else if (shift == W_TYPE_SIZE - 1)
|
|
|
1521 e = Wtype_MAXp1_F / 2;
|
|
|
1522 else
|
|
|
1523 e = (Wtype)1 << shift;
|
|
|
1524 return f * e;
|
|
|
1525 #endif
|
|
|
1526 }
|
|
|
1527 #endif
|
|
|
1528
|
|
|
1529 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
|
|
|
1530 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
|
|
|
1531 #define DI_SIZE (W_TYPE_SIZE * 2)
|
|
|
1532 #define F_MODE_OK(SIZE) \
|
|
|
1533 (SIZE < DI_SIZE \
|
|
|
1534 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
|
|
|
1535 && !AVOID_FP_TYPE_CONVERSION(SIZE))
|
|
|
1536 #if defined(L_floatundisf)
|
|
|
1537 #define FUNC __floatundisf
|
|
|
1538 #define FSTYPE SFtype
|
|
|
1539 #define FSSIZE SF_SIZE
|
|
|
1540 #else
|
|
|
1541 #define FUNC __floatundidf
|
|
|
1542 #define FSTYPE DFtype
|
|
|
1543 #define FSSIZE DF_SIZE
|
|
|
1544 #endif
|
|
|
1545
|
|
|
1546 FSTYPE
|
|
|
1547 FUNC (UDWtype u)
|
|
|
1548 {
|
|
|
1549 #if FSSIZE >= W_TYPE_SIZE
|
|
|
1550 /* When the word size is small, we never get any rounding error. */
|
|
|
1551 FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
|
|
|
1552 f *= Wtype_MAXp1_F;
|
|
|
1553 f += (UWtype)u;
|
|
|
1554 return f;
|
|
|
1555 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
|
|
|
1556 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
|
|
|
1557 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
|
|
|
1558
|
|
|
1559 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
|
|
|
1560 # define FSIZE DF_SIZE
|
|
|
1561 # define FTYPE DFtype
|
|
|
1562 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
|
|
|
1563 # define FSIZE XF_SIZE
|
|
|
1564 # define FTYPE XFtype
|
|
|
1565 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
|
|
|
1566 # define FSIZE TF_SIZE
|
|
|
1567 # define FTYPE TFtype
|
|
|
1568 #else
|
|
|
1569 # error
|
|
|
1570 #endif
|
|
|
1571
|
|
|
1572 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
|
|
|
1573
|
|
|
1574 /* Protect against double-rounding error.
|
|
|
1575 Represent any low-order bits, that might be truncated by a bit that
|
|
|
1576 won't be lost. The bit can go in anywhere below the rounding position
|
|
|
1577 of the FSTYPE. A fixed mask and bit position handles all usual
|
|
|
1578 configurations. */
|
|
|
1579 if (u >= ((UDWtype) 1 << FSIZE))
|
|
|
1580 {
|
|
|
1581 if ((UDWtype) u & (REP_BIT - 1))
|
|
|
1582 {
|
|
|
1583 u &= ~ (REP_BIT - 1);
|
|
|
1584 u |= REP_BIT;
|
|
|
1585 }
|
|
|
1586 }
|
|
|
1587
|
|
|
1588 /* Do the calculation in a wider type so that we don't lose any of
|
|
|
1589 the precision of the high word while multiplying it. */
|
|
|
1590 FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
|
|
|
1591 f *= Wtype_MAXp1_F;
|
|
|
1592 f += (UWtype)u;
|
|
|
1593 return (FSTYPE) f;
|
|
|
1594 #else
|
|
|
1595 #if FSSIZE == W_TYPE_SIZE - 1
|
|
|
1596 # error
|
|
|
1597 #endif
|
|
|
1598 /* Finally, the word size is larger than the number of bits in the
|
|
|
1599 required FSTYPE, and we've got no suitable wider type. The only
|
|
|
1600 way to avoid double rounding is to special case the
|
|
|
1601 extraction. */
|
|
|
1602
|
|
|
1603 /* If there are no high bits set, fall back to one conversion. */
|
|
|
1604 if ((UWtype)u == u)
|
|
|
1605 return (FSTYPE)(UWtype)u;
|
|
|
1606
|
|
|
1607 /* Otherwise, find the power of two. */
|
|
|
1608 UWtype hi = u >> W_TYPE_SIZE;
|
|
|
1609
|
|
|
1610 UWtype count, shift;
|
|
|
1611 count_leading_zeros (count, hi);
|
|
|
1612
|
|
|
1613 shift = W_TYPE_SIZE - count;
|
|
|
1614
|
|
|
1615 /* Shift down the most significant bits. */
|
|
|
1616 hi = u >> shift;
|
|
|
1617
|
|
|
1618 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
|
|
|
1619 if ((UWtype)u << (W_TYPE_SIZE - shift))
|
|
|
1620 hi |= 1;
|
|
|
1621
|
|
|
1622 /* Convert the one word of data, and rescale. */
|
|
|
1623 FSTYPE f = hi, e;
|
|
|
1624 if (shift == W_TYPE_SIZE)
|
|
|
1625 e = Wtype_MAXp1_F;
|
|
|
1626 /* The following two cases could be merged if we knew that the target
|
|
|
1627 supported a native unsigned->float conversion. More often, we only
|
|
|
1628 have a signed conversion, and have to add extra fixup code. */
|
|
|
1629 else if (shift == W_TYPE_SIZE - 1)
|
|
|
1630 e = Wtype_MAXp1_F / 2;
|
|
|
1631 else
|
|
|
1632 e = (Wtype)1 << shift;
|
|
|
1633 return f * e;
|
|
|
1634 #endif
|
|
|
1635 }
|
|
|
1636 #endif
|
|
|
1637
|
|
|
1638 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
|
|
|
1639 /* Reenable the normal types, in case limits.h needs them. */
|
|
|
1640 #undef char
|
|
|
1641 #undef short
|
|
|
1642 #undef int
|
|
|
1643 #undef long
|
|
|
1644 #undef unsigned
|
|
|
1645 #undef float
|
|
|
1646 #undef double
|
|
|
1647 #undef MIN
|
|
|
1648 #undef MAX
|
|
|
1649 #include <limits.h>
|
|
|
1650
|
|
|
1651 UWtype
|
|
|
1652 __fixunsxfSI (XFtype a)
|
|
|
1653 {
|
|
|
1654 if (a >= - (DFtype) Wtype_MIN)
|
|
|
1655 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
1656 return (Wtype) a;
|
|
|
1657 }
|
|
|
1658 #endif
|
|
|
1659
|
|
|
1660 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
|
|
|
1661 /* Reenable the normal types, in case limits.h needs them. */
|
|
|
1662 #undef char
|
|
|
1663 #undef short
|
|
|
1664 #undef int
|
|
|
1665 #undef long
|
|
|
1666 #undef unsigned
|
|
|
1667 #undef float
|
|
|
1668 #undef double
|
|
|
1669 #undef MIN
|
|
|
1670 #undef MAX
|
|
|
1671 #include <limits.h>
|
|
|
1672
|
|
|
1673 UWtype
|
|
|
1674 __fixunsdfSI (DFtype a)
|
|
|
1675 {
|
|
|
1676 if (a >= - (DFtype) Wtype_MIN)
|
|
|
1677 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
1678 return (Wtype) a;
|
|
|
1679 }
|
|
|
1680 #endif
|
|
|
1681
|
|
|
1682 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
|
|
|
1683 /* Reenable the normal types, in case limits.h needs them. */
|
|
|
1684 #undef char
|
|
|
1685 #undef short
|
|
|
1686 #undef int
|
|
|
1687 #undef long
|
|
|
1688 #undef unsigned
|
|
|
1689 #undef float
|
|
|
1690 #undef double
|
|
|
1691 #undef MIN
|
|
|
1692 #undef MAX
|
|
|
1693 #include <limits.h>
|
|
|
1694
|
|
|
1695 UWtype
|
|
|
1696 __fixunssfSI (SFtype a)
|
|
|
1697 {
|
|
|
1698 if (a >= - (SFtype) Wtype_MIN)
|
|
|
1699 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
|
|
|
1700 return (Wtype) a;
|
|
|
1701 }
|
|
|
1702 #endif
|
|
|
1703
|
|
|
1704 /* Integer power helper used from __builtin_powi for non-constant
|
|
|
1705 exponents. */
|
|
|
1706
|
|
|
1707 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
|
|
|
1708 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
|
|
|
1709 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
|
|
|
1710 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
|
|
|
1711 # if defined(L_powisf2)
|
|
|
1712 # define TYPE SFtype
|
|
|
1713 # define NAME __powisf2
|
|
|
1714 # elif defined(L_powidf2)
|
|
|
1715 # define TYPE DFtype
|
|
|
1716 # define NAME __powidf2
|
|
|
1717 # elif defined(L_powixf2)
|
|
|
1718 # define TYPE XFtype
|
|
|
1719 # define NAME __powixf2
|
|
|
1720 # elif defined(L_powitf2)
|
|
|
1721 # define TYPE TFtype
|
|
|
1722 # define NAME __powitf2
|
|
|
1723 # endif
|
|
|
1724
|
|
|
1725 #undef int
|
|
|
1726 #undef unsigned
|
|
|
1727 TYPE
|
|
|
1728 NAME (TYPE x, int m)
|
|
|
1729 {
|
|
|
1730 unsigned int n = m < 0 ? -m : m;
|
|
|
1731 TYPE y = n % 2 ? x : 1;
|
|
|
1732 while (n >>= 1)
|
|
|
1733 {
|
|
|
1734 x = x * x;
|
|
|
1735 if (n % 2)
|
|
|
1736 y = y * x;
|
|
|
1737 }
|
|
|
1738 return m < 0 ? 1/y : y;
|
|
|
1739 }
|
|
|
1740
|
|
|
1741 #endif
|
|
|
1742
|
|
|
1743 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
|
|
|
1744 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
|
|
|
1745 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
|
|
|
1746 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
|
|
|
1747
|
|
|
1748 #undef float
|
|
|
1749 #undef double
|
|
|
1750 #undef long
|
|
|
1751
|
|
|
1752 #if defined(L_mulsc3) || defined(L_divsc3)
|
|
|
1753 # define MTYPE SFtype
|
|
|
1754 # define CTYPE SCtype
|
|
|
1755 # define MODE sc
|
|
|
1756 # define CEXT f
|
|
|
1757 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
|
|
|
1758 #elif defined(L_muldc3) || defined(L_divdc3)
|
|
|
1759 # define MTYPE DFtype
|
|
|
1760 # define CTYPE DCtype
|
|
|
1761 # define MODE dc
|
|
|
1762 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
|
|
|
1763 # define CEXT l
|
|
|
1764 # define NOTRUNC 1
|
|
|
1765 # else
|
|
|
1766 # define CEXT
|
|
|
1767 # define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
|
|
|
1768 # endif
|
|
|
1769 #elif defined(L_mulxc3) || defined(L_divxc3)
|
|
|
1770 # define MTYPE XFtype
|
|
|
1771 # define CTYPE XCtype
|
|
|
1772 # define MODE xc
|
|
|
1773 # define CEXT l
|
|
|
1774 # define NOTRUNC 1
|
|
|
1775 #elif defined(L_multc3) || defined(L_divtc3)
|
|
|
1776 # define MTYPE TFtype
|
|
|
1777 # define CTYPE TCtype
|
|
|
1778 # define MODE tc
|
|
|
1779 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
|
|
|
1780 # define CEXT l
|
|
|
1781 # else
|
|
|
1782 # define CEXT LIBGCC2_TF_CEXT
|
|
|
1783 # endif
|
|
|
1784 # define NOTRUNC 1
|
|
|
1785 #else
|
|
|
1786 # error
|
|
|
1787 #endif
|
|
|
1788
|
|
|
1789 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
|
|
|
1790 #define _CONCAT3(A,B,C) A##B##C
|
|
|
1791
|
|
|
1792 #define CONCAT2(A,B) _CONCAT2(A,B)
|
|
|
1793 #define _CONCAT2(A,B) A##B
|
|
|
1794
|
|
|
1795 /* All of these would be present in a full C99 implementation of <math.h>
|
|
|
1796 and <complex.h>. Our problem is that only a few systems have such full
|
|
|
1797 implementations. Further, libgcc_s.so isn't currently linked against
|
|
|
1798 libm.so, and even for systems that do provide full C99, the extra overhead
|
|
|
1799 of all programs using libgcc having to link against libm. So avoid it. */
|
|
|
1800
|
|
|
1801 #define isnan(x) __builtin_expect ((x) != (x), 0)
|
|
|
1802 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
|
|
|
1803 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
|
|
|
1804
|
|
|
1805 #define INFINITY CONCAT2(__builtin_inf, CEXT) ()
|
|
|
1806 #define I 1i
|
|
|
1807
|
|
|
1808 /* Helpers to make the following code slightly less gross. */
|
|
|
1809 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
|
|
|
1810 #define FABS CONCAT2(__builtin_fabs, CEXT)
|
|
|
1811
|
|
|
1812 /* Verify that MTYPE matches up with CEXT. */
|
|
|
1813 extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
|
|
|
1814
|
|
|
1815 /* Ensure that we've lost any extra precision. */
|
|
|
1816 #if NOTRUNC
|
|
|
1817 # define TRUNC(x)
|
|
|
1818 #else
|
|
|
1819 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
|
|
|
1820 #endif
|
|
|
1821
|
|
|
1822 #if defined(L_mulsc3) || defined(L_muldc3) \
|
|
|
1823 || defined(L_mulxc3) || defined(L_multc3)
|
|
|
1824
|
|
|
1825 CTYPE
|
|
|
1826 CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
|
|
|
1827 {
|
|
|
1828 MTYPE ac, bd, ad, bc, x, y;
|
|
|
1829 CTYPE res;
|
|
|
1830
|
|
|
1831 ac = a * c;
|
|
|
1832 bd = b * d;
|
|
|
1833 ad = a * d;
|
|
|
1834 bc = b * c;
|
|
|
1835
|
|
|
1836 TRUNC (ac);
|
|
|
1837 TRUNC (bd);
|
|
|
1838 TRUNC (ad);
|
|
|
1839 TRUNC (bc);
|
|
|
1840
|
|
|
1841 x = ac - bd;
|
|
|
1842 y = ad + bc;
|
|
|
1843
|
|
|
1844 if (isnan (x) && isnan (y))
|
|
|
1845 {
|
|
|
1846 /* Recover infinities that computed as NaN + iNaN. */
|
|
|
1847 _Bool recalc = 0;
|
|
|
1848 if (isinf (a) || isinf (b))
|
|
|
1849 {
|
|
|
1850 /* z is infinite. "Box" the infinity and change NaNs in
|
|
|
1851 the other factor to 0. */
|
|
|
1852 a = COPYSIGN (isinf (a) ? 1 : 0, a);
|
|
|
1853 b = COPYSIGN (isinf (b) ? 1 : 0, b);
|
|
|
1854 if (isnan (c)) c = COPYSIGN (0, c);
|
|
|
1855 if (isnan (d)) d = COPYSIGN (0, d);
|
|
|
1856 recalc = 1;
|
|
|
1857 }
|
|
|
1858 if (isinf (c) || isinf (d))
|
|
|
1859 {
|
|
|
1860 /* w is infinite. "Box" the infinity and change NaNs in
|
|
|
1861 the other factor to 0. */
|
|
|
1862 c = COPYSIGN (isinf (c) ? 1 : 0, c);
|
|
|
1863 d = COPYSIGN (isinf (d) ? 1 : 0, d);
|
|
|
1864 if (isnan (a)) a = COPYSIGN (0, a);
|
|
|
1865 if (isnan (b)) b = COPYSIGN (0, b);
|
|
|
1866 recalc = 1;
|
|
|
1867 }
|
|
|
1868 if (!recalc
|
|
|
1869 && (isinf (ac) || isinf (bd)
|
|
|
1870 || isinf (ad) || isinf (bc)))
|
|
|
1871 {
|
|
|
1872 /* Recover infinities from overflow by changing NaNs to 0. */
|
|
|
1873 if (isnan (a)) a = COPYSIGN (0, a);
|
|
|
1874 if (isnan (b)) b = COPYSIGN (0, b);
|
|
|
1875 if (isnan (c)) c = COPYSIGN (0, c);
|
|
|
1876 if (isnan (d)) d = COPYSIGN (0, d);
|
|
|
1877 recalc = 1;
|
|
|
1878 }
|
|
|
1879 if (recalc)
|
|
|
1880 {
|
|
|
1881 x = INFINITY * (a * c - b * d);
|
|
|
1882 y = INFINITY * (a * d + b * c);
|
|
|
1883 }
|
|
|
1884 }
|
|
|
1885
|
|
|
1886 __real__ res = x;
|
|
|
1887 __imag__ res = y;
|
|
|
1888 return res;
|
|
|
1889 }
|
|
|
1890 #endif /* complex multiply */
|
|
|
1891
|
|
|
1892 #if defined(L_divsc3) || defined(L_divdc3) \
|
|
|
1893 || defined(L_divxc3) || defined(L_divtc3)
|
|
|
1894
|
|
|
1895 CTYPE
|
|
|
1896 CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
|
|
|
1897 {
|
|
|
1898 MTYPE denom, ratio, x, y;
|
|
|
1899 CTYPE res;
|
|
|
1900
|
|
|
1901 /* ??? We can get better behavior from logarithmic scaling instead of
|
|
|
1902 the division. But that would mean starting to link libgcc against
|
|
|
1903 libm. We could implement something akin to ldexp/frexp as gcc builtins
|
|
|
1904 fairly easily... */
|
|
|
1905 if (FABS (c) < FABS (d))
|
|
|
1906 {
|
|
|
1907 ratio = c / d;
|
|
|
1908 denom = (c * ratio) + d;
|
|
|
1909 x = ((a * ratio) + b) / denom;
|
|
|
1910 y = ((b * ratio) - a) / denom;
|
|
|
1911 }
|
|
|
1912 else
|
|
|
1913 {
|
|
|
1914 ratio = d / c;
|
|
|
1915 denom = (d * ratio) + c;
|
|
|
1916 x = ((b * ratio) + a) / denom;
|
|
|
1917 y = (b - (a * ratio)) / denom;
|
|
|
1918 }
|
|
|
1919
|
|
|
1920 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
|
|
|
1921 are nonzero/zero, infinite/finite, and finite/infinite. */
|
|
|
1922 if (isnan (x) && isnan (y))
|
|
|
1923 {
|
|
|
1924 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
|
|
|
1925 {
|
|
|
1926 x = COPYSIGN (INFINITY, c) * a;
|
|
|
1927 y = COPYSIGN (INFINITY, c) * b;
|
|
|
1928 }
|
|
|
1929 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
|
|
|
1930 {
|
|
|
1931 a = COPYSIGN (isinf (a) ? 1 : 0, a);
|
|
|
1932 b = COPYSIGN (isinf (b) ? 1 : 0, b);
|
|
|
1933 x = INFINITY * (a * c + b * d);
|
|
|
1934 y = INFINITY * (b * c - a * d);
|
|
|
1935 }
|
|
|
1936 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
|
|
|
1937 {
|
|
|
1938 c = COPYSIGN (isinf (c) ? 1 : 0, c);
|
|
|
1939 d = COPYSIGN (isinf (d) ? 1 : 0, d);
|
|
|
1940 x = 0.0 * (a * c + b * d);
|
|
|
1941 y = 0.0 * (b * c - a * d);
|
|
|
1942 }
|
|
|
1943 }
|
|
|
1944
|
|
|
1945 __real__ res = x;
|
|
|
1946 __imag__ res = y;
|
|
|
1947 return res;
|
|
|
1948 }
|
|
|
1949 #endif /* complex divide */
|
|
|
1950
|
|
|
1951 #endif /* all complex float routines */
|
|
|
1952
|
|
|
1953 /* From here on down, the routines use normal data types. */
|
|
|
1954
|
|
|
1955 #define SItype bogus_type
|
|
|
1956 #define USItype bogus_type
|
|
|
1957 #define DItype bogus_type
|
|
|
1958 #define UDItype bogus_type
|
|
|
1959 #define SFtype bogus_type
|
|
|
1960 #define DFtype bogus_type
|
|
|
1961 #undef Wtype
|
|
|
1962 #undef UWtype
|
|
|
1963 #undef HWtype
|
|
|
1964 #undef UHWtype
|
|
|
1965 #undef DWtype
|
|
|
1966 #undef UDWtype
|
|
|
1967
|
|
|
1968 #undef char
|
|
|
1969 #undef short
|
|
|
1970 #undef int
|
|
|
1971 #undef long
|
|
|
1972 #undef unsigned
|
|
|
1973 #undef float
|
|
|
1974 #undef double
|
|
|
1975
|
|
|
1976 #ifdef L__gcc_bcmp
|
|
|
1977
|
|
|
1978 /* Like bcmp except the sign is meaningful.
|
|
|
1979 Result is negative if S1 is less than S2,
|
|
|
1980 positive if S1 is greater, 0 if S1 and S2 are equal. */
|
|
|
1981
|
|
|
1982 int
|
|
|
1983 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
|
|
|
1984 {
|
|
|
1985 while (size > 0)
|
|
|
1986 {
|
|
|
1987 const unsigned char c1 = *s1++, c2 = *s2++;
|
|
|
1988 if (c1 != c2)
|
|
|
1989 return c1 - c2;
|
|
|
1990 size--;
|
|
|
1991 }
|
|
|
1992 return 0;
|
|
|
1993 }
|
|
|
1994
|
|
|
1995 #endif
|
|
|
1996
|
|
|
1997 /* __eprintf used to be used by GCC's private version of <assert.h>.
|
|
|
1998 We no longer provide that header, but this routine remains in libgcc.a
|
|
|
1999 for binary backward compatibility. Note that it is not included in
|
|
|
2000 the shared version of libgcc. */
|
|
|
2001 #ifdef L_eprintf
|
|
|
2002 #ifndef inhibit_libc
|
|
|
2003
|
|
|
2004 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
|
|
|
2005 #include <stdio.h>
|
|
|
2006
|
|
|
2007 void
|
|
|
2008 __eprintf (const char *string, const char *expression,
|
|
|
2009 unsigned int line, const char *filename)
|
|
|
2010 {
|
|
|
2011 fprintf (stderr, string, expression, line, filename);
|
|
|
2012 fflush (stderr);
|
|
|
2013 abort ();
|
|
|
2014 }
|
|
|
2015
|
|
|
2016 #endif
|
|
|
2017 #endif
|
|
|
2018
|
|
|
2019
|
|
|
2020 #ifdef L_clear_cache
|
|
|
2021 /* Clear part of an instruction cache. */
|
|
|
2022
|
|
|
2023 void
|
|
|
2024 __clear_cache (char *beg __attribute__((__unused__)),
|
|
|
2025 char *end __attribute__((__unused__)))
|
|
|
2026 {
|
|
|
2027 #ifdef CLEAR_INSN_CACHE
|
|
|
2028 CLEAR_INSN_CACHE (beg, end);
|
|
|
2029 #endif /* CLEAR_INSN_CACHE */
|
|
|
2030 }
|
|
|
2031
|
|
|
2032 #endif /* L_clear_cache */
|
|
|
2033
|
|
|
2034 #ifdef L_enable_execute_stack
|
|
|
2035 /* Attempt to turn on execute permission for the stack. */
|
|
|
2036
|
|
|
2037 #ifdef ENABLE_EXECUTE_STACK
|
|
|
2038 ENABLE_EXECUTE_STACK
|
|
|
2039 #else
|
|
|
2040 void
|
|
|
2041 __enable_execute_stack (void *addr __attribute__((__unused__)))
|
|
|
2042 {}
|
|
|
2043 #endif /* ENABLE_EXECUTE_STACK */
|
|
|
2044
|
|
|
2045 #endif /* L_enable_execute_stack */
|
|
|
2046
|
|
|
2047 #ifdef L_trampoline
|
|
|
2048
|
|
|
2049 /* Jump to a trampoline, loading the static chain address. */
|
|
|
2050
|
|
|
2051 #if defined(WINNT) && ! defined(__CYGWIN__)
|
|
|
2052
|
|
|
2053 int
|
|
|
2054 getpagesize (void)
|
|
|
2055 {
|
|
|
2056 #ifdef _ALPHA_
|
|
|
2057 return 8192;
|
|
|
2058 #else
|
|
|
2059 return 4096;
|
|
|
2060 #endif
|
|
|
2061 }
|
|
|
2062
|
|
|
2063 int
|
|
|
2064 mprotect (char *addr, int len, int prot)
|
|
|
2065 {
|
|
|
2066 DWORD np, op;
|
|
|
2067
|
|
|
2068 if (prot == 7)
|
|
|
2069 np = 0x40;
|
|
|
2070 else if (prot == 5)
|
|
|
2071 np = 0x20;
|
|
|
2072 else if (prot == 4)
|
|
|
2073 np = 0x10;
|
|
|
2074 else if (prot == 3)
|
|
|
2075 np = 0x04;
|
|
|
2076 else if (prot == 1)
|
|
|
2077 np = 0x02;
|
|
|
2078 else if (prot == 0)
|
|
|
2079 np = 0x01;
|
|
|
2080 else
|
|
|
2081 return -1;
|
|
|
2082
|
|
|
2083 if (VirtualProtect (addr, len, np, &op))
|
|
|
2084 return 0;
|
|
|
2085 else
|
|
|
2086 return -1;
|
|
|
2087 }
|
|
|
2088
|
|
|
2089 #endif /* WINNT && ! __CYGWIN__ */
|
|
|
2090
|
|
|
2091 #ifdef TRANSFER_FROM_TRAMPOLINE
|
|
|
2092 TRANSFER_FROM_TRAMPOLINE
|
|
|
2093 #endif
|
|
|
2094 #endif /* L_trampoline */
|
|
|
2095
|
|
|
2096 #ifndef __CYGWIN__
|
|
|
2097 #ifdef L__main
|
|
|
2098
|
|
|
2099 #include "gbl-ctors.h"
|
|
|
2100
|
|
|
2101 /* Some systems use __main in a way incompatible with its use in gcc, in these
|
|
|
2102 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
|
|
|
2103 give the same symbol without quotes for an alternative entry point. You
|
|
|
2104 must define both, or neither. */
|
|
|
2105 #ifndef NAME__MAIN
|
|
|
2106 #define NAME__MAIN "__main"
|
|
|
2107 #define SYMBOL__MAIN __main
|
|
|
2108 #endif
|
|
|
2109
|
|
|
2110 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
|
|
|
2111 #undef HAS_INIT_SECTION
|
|
|
2112 #define HAS_INIT_SECTION
|
|
|
2113 #endif
|
|
|
2114
|
|
|
2115 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
|
|
|
2116
|
|
|
2117 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
|
|
|
2118 code to run constructors. In that case, we need to handle EH here, too. */
|
|
|
2119
|
|
|
2120 #ifdef EH_FRAME_SECTION_NAME
|
|
|
2121 #include "unwind-dw2-fde.h"
|
|
|
2122 extern unsigned char __EH_FRAME_BEGIN__[];
|
|
|
2123 #endif
|
|
|
2124
|
|
|
2125 /* Run all the global destructors on exit from the program. */
|
|
|
2126
|
|
|
2127 void
|
|
|
2128 __do_global_dtors (void)
|
|
|
2129 {
|
|
|
2130 #ifdef DO_GLOBAL_DTORS_BODY
|
|
|
2131 DO_GLOBAL_DTORS_BODY;
|
|
|
2132 #else
|
|
|
2133 static func_ptr *p = __DTOR_LIST__ + 1;
|
|
|
2134 while (*p)
|
|
|
2135 {
|
|
|
2136 p++;
|
|
|
2137 (*(p-1)) ();
|
|
|
2138 }
|
|
|
2139 #endif
|
|
|
2140 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
|
|
|
2141 {
|
|
|
2142 static int completed = 0;
|
|
|
2143 if (! completed)
|
|
|
2144 {
|
|
|
2145 completed = 1;
|
|
|
2146 __deregister_frame_info (__EH_FRAME_BEGIN__);
|
|
|
2147 }
|
|
|
2148 }
|
|
|
2149 #endif
|
|
|
2150 }
|
|
|
2151 #endif
|
|
|
2152
|
|
|
2153 #ifndef HAS_INIT_SECTION
|
|
|
2154 /* Run all the global constructors on entry to the program. */
|
|
|
2155
|
|
|
2156 void
|
|
|
2157 __do_global_ctors (void)
|
|
|
2158 {
|
|
|
2159 #ifdef EH_FRAME_SECTION_NAME
|
|
|
2160 {
|
|
|
2161 static struct object object;
|
|
|
2162 __register_frame_info (__EH_FRAME_BEGIN__, &object);
|
|
|
2163 }
|
|
|
2164 #endif
|
|
|
2165 DO_GLOBAL_CTORS_BODY;
|
|
|
2166 atexit (__do_global_dtors);
|
|
|
2167 }
|
|
|
2168 #endif /* no HAS_INIT_SECTION */
|
|
|
2169
|
|
|
2170 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
|
|
|
2171 /* Subroutine called automatically by `main'.
|
|
|
2172 Compiling a global function named `main'
|
|
|
2173 produces an automatic call to this function at the beginning.
|
|
|
2174
|
|
|
2175 For many systems, this routine calls __do_global_ctors.
|
|
|
2176 For systems which support a .init section we use the .init section
|
|
|
2177 to run __do_global_ctors, so we need not do anything here. */
|
|
|
2178
|
|
|
2179 extern void SYMBOL__MAIN (void);
|
|
|
2180 void
|
|
|
2181 SYMBOL__MAIN (void)
|
|
|
2182 {
|
|
|
2183 /* Support recursive calls to `main': run initializers just once. */
|
|
|
2184 static int initialized;
|
|
|
2185 if (! initialized)
|
|
|
2186 {
|
|
|
2187 initialized = 1;
|
|
|
2188 __do_global_ctors ();
|
|
|
2189 }
|
|
|
2190 }
|
|
|
2191 #endif /* no HAS_INIT_SECTION or INVOKE__main */
|
|
|
2192
|
|
|
2193 #endif /* L__main */
|
|
|
2194 #endif /* __CYGWIN__ */
|
|
|
2195
|
|
|
2196 #ifdef L_ctors
|
|
|
2197
|
|
|
2198 #include "gbl-ctors.h"
|
|
|
2199
|
|
|
2200 /* Provide default definitions for the lists of constructors and
|
|
|
2201 destructors, so that we don't get linker errors. These symbols are
|
|
|
2202 intentionally bss symbols, so that gld and/or collect will provide
|
|
|
2203 the right values. */
|
|
|
2204
|
|
|
2205 /* We declare the lists here with two elements each,
|
|
|
2206 so that they are valid empty lists if no other definition is loaded.
|
|
|
2207
|
|
|
2208 If we are using the old "set" extensions to have the gnu linker
|
|
|
2209 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
|
|
|
2210 must be in the bss/common section.
|
|
|
2211
|
|
|
2212 Long term no port should use those extensions. But many still do. */
|
|
|
2213 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
|
|
|
2214 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
|
|
|
2215 func_ptr __CTOR_LIST__[2] = {0, 0};
|
|
|
2216 func_ptr __DTOR_LIST__[2] = {0, 0};
|
|
|
2217 #else
|
|
|
2218 func_ptr __CTOR_LIST__[2];
|
|
|
2219 func_ptr __DTOR_LIST__[2];
|
|
|
2220 #endif
|
|
|
2221 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
|
|
|
2222 #endif /* L_ctors */
|
|
|
2223 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */
|
