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