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 Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file. (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combine
20 executable.)
21
22 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
24 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25 for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with GCC; see the file COPYING. If not, write to the Free
29 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 02111-1307, USA. */
31
32 /* It is incorrect to include config.h here, because this file is being
33 compiled for the target, and hence definitions concerning only the host
34 do not apply. */
35
36 #include "tconfig.h"
37 #include "tsystem.h"
38
39 /* Don't use `fancy_abort' here even if config.h says to use it. */
40 #ifdef abort
41 #undef abort
42 #endif
43
44 #include "libgcc2.h"
45
46 #ifdef DECLARE_LIBRARY_RENAMES
47 DECLARE_LIBRARY_RENAMES
48 #endif
49
50 #if defined (L_negdi2)
51 DWtype
__negdi2(DWtype u)52 __negdi2 (DWtype u)
53 {
54 DWunion w;
55 DWunion uu;
56
57 uu.ll = u;
58
59 w.s.low = -uu.s.low;
60 w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
61
62 return w.ll;
63 }
64 #endif
65
66 #ifdef L_addvsi3
67 Wtype
__addvsi3(Wtype a,Wtype b)68 __addvsi3 (Wtype a, Wtype b)
69 {
70 Wtype w;
71
72 w = a + b;
73
74 if (b >= 0 ? w < a : w > a)
75 abort ();
76
77 return w;
78 }
79 #endif
80
81 #ifdef L_addvdi3
82 DWtype
__addvdi3(DWtype a,DWtype b)83 __addvdi3 (DWtype a, DWtype b)
84 {
85 DWtype w;
86
87 w = a + b;
88
89 if (b >= 0 ? w < a : w > a)
90 abort ();
91
92 return w;
93 }
94 #endif
95
96 #ifdef L_subvsi3
97 Wtype
__subvsi3(Wtype a,Wtype b)98 __subvsi3 (Wtype a, Wtype b)
99 {
100 #ifdef L_addvsi3
101 return __addvsi3 (a, (-b));
102 #else
103 DWtype w;
104
105 w = a - b;
106
107 if (b >= 0 ? w > a : w < a)
108 abort ();
109
110 return w;
111 #endif
112 }
113 #endif
114
115 #ifdef L_subvdi3
116 DWtype
__subvdi3(DWtype a,DWtype b)117 __subvdi3 (DWtype a, DWtype b)
118 {
119 #ifdef L_addvdi3
120 return (a, (-b));
121 #else
122 DWtype w;
123
124 w = a - b;
125
126 if (b >= 0 ? w > a : w < a)
127 abort ();
128
129 return w;
130 #endif
131 }
132 #endif
133
134 #ifdef L_mulvsi3
135 Wtype
__mulvsi3(Wtype a,Wtype b)136 __mulvsi3 (Wtype a, Wtype b)
137 {
138 DWtype w;
139
140 w = a * b;
141
142 if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
143 abort ();
144
145 return w;
146 }
147 #endif
148
149 #ifdef L_negvsi2
150 Wtype
__negvsi2(Wtype a)151 __negvsi2 (Wtype a)
152 {
153 Wtype w;
154
155 w = -a;
156
157 if (a >= 0 ? w > 0 : w < 0)
158 abort ();
159
160 return w;
161 }
162 #endif
163
164 #ifdef L_negvdi2
165 DWtype
__negvdi2(DWtype a)166 __negvdi2 (DWtype a)
167 {
168 DWtype w;
169
170 w = -a;
171
172 if (a >= 0 ? w > 0 : w < 0)
173 abort ();
174
175 return w;
176 }
177 #endif
178
179 #ifdef L_absvsi2
180 Wtype
__absvsi2(Wtype a)181 __absvsi2 (Wtype a)
182 {
183 Wtype w = a;
184
185 if (a < 0)
186 #ifdef L_negvsi2
187 w = __negvsi2 (a);
188 #else
189 w = -a;
190
191 if (w < 0)
192 abort ();
193 #endif
194
195 return w;
196 }
197 #endif
198
199 #ifdef L_absvdi2
200 DWtype
__absvdi2(DWtype a)201 __absvdi2 (DWtype a)
202 {
203 DWtype w = a;
204
205 if (a < 0)
206 #ifdef L_negvsi2
207 w = __negvsi2 (a);
208 #else
209 w = -a;
210
211 if (w < 0)
212 abort ();
213 #endif
214
215 return w;
216 }
217 #endif
218
219 #ifdef L_mulvdi3
220 DWtype
__mulvdi3(DWtype u,DWtype v)221 __mulvdi3 (DWtype u, DWtype v)
222 {
223 DWtype w;
224
225 w = u * v;
226
227 if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
228 abort ();
229
230 return w;
231 }
232 #endif
233
234
235 /* Unless shift functions are defined whith full ANSI prototypes,
236 parameter b will be promoted to int if word_type is smaller than an int. */
237 #ifdef L_lshrdi3
238 DWtype
__lshrdi3(DWtype u,word_type b)239 __lshrdi3 (DWtype u, word_type b)
240 {
241 DWunion w;
242 word_type bm;
243 DWunion uu;
244
245 if (b == 0)
246 return u;
247
248 uu.ll = u;
249
250 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
251 if (bm <= 0)
252 {
253 w.s.high = 0;
254 w.s.low = (UWtype) uu.s.high >> -bm;
255 }
256 else
257 {
258 UWtype carries = (UWtype) uu.s.high << bm;
259
260 w.s.high = (UWtype) uu.s.high >> b;
261 w.s.low = ((UWtype) uu.s.low >> b) | carries;
262 }
263
264 return w.ll;
265 }
266 #endif
267
268 #ifdef L_ashldi3
269 DWtype
__ashldi3(DWtype u,word_type b)270 __ashldi3 (DWtype u, word_type b)
271 {
272 DWunion w;
273 word_type bm;
274 DWunion uu;
275
276 if (b == 0)
277 return u;
278
279 uu.ll = u;
280
281 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
282 if (bm <= 0)
283 {
284 w.s.low = 0;
285 w.s.high = (UWtype) uu.s.low << -bm;
286 }
287 else
288 {
289 UWtype carries = (UWtype) uu.s.low >> bm;
290
291 w.s.low = (UWtype) uu.s.low << b;
292 w.s.high = ((UWtype) uu.s.high << b) | carries;
293 }
294
295 return w.ll;
296 }
297 #endif
298
299 #ifdef L_ashrdi3
300 DWtype
__ashrdi3(DWtype u,word_type b)301 __ashrdi3 (DWtype u, word_type b)
302 {
303 DWunion w;
304 word_type bm;
305 DWunion uu;
306
307 if (b == 0)
308 return u;
309
310 uu.ll = u;
311
312 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
313 if (bm <= 0)
314 {
315 /* w.s.high = 1..1 or 0..0 */
316 w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
317 w.s.low = uu.s.high >> -bm;
318 }
319 else
320 {
321 UWtype carries = (UWtype) uu.s.high << bm;
322
323 w.s.high = uu.s.high >> b;
324 w.s.low = ((UWtype) uu.s.low >> b) | carries;
325 }
326
327 return w.ll;
328 }
329 #endif
330
331 #ifdef L_ffsdi2
332 DWtype
__ffsdi2(DWtype u)333 __ffsdi2 (DWtype u)
334 {
335 DWunion uu;
336 UWtype word, count, add;
337
338 uu.ll = u;
339 if (uu.s.low != 0)
340 word = uu.s.low, add = 0;
341 else if (uu.s.high != 0)
342 word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
343 else
344 return 0;
345
346 count_trailing_zeros (count, word);
347 return count + add + 1;
348 }
349 #endif
350
351 #ifdef L_muldi3
352 DWtype
__muldi3(DWtype u,DWtype v)353 __muldi3 (DWtype u, DWtype v)
354 {
355 DWunion w;
356 DWunion uu, vv;
357
358 uu.ll = u,
359 vv.ll = v;
360
361 w.ll = __umulsidi3 (uu.s.low, vv.s.low);
362 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
363 + (UWtype) uu.s.high * (UWtype) vv.s.low);
364
365 return w.ll;
366 }
367 #endif
368
369 #if (defined (L_udivdi3) || defined (L_divdi3) || \
370 defined (L_umoddi3) || defined (L_moddi3))
371 #if defined (sdiv_qrnnd)
372 #define L_udiv_w_sdiv
373 #endif
374 #endif
375
376 #ifdef L_udiv_w_sdiv
377 #if defined (sdiv_qrnnd)
378 #if (defined (L_udivdi3) || defined (L_divdi3) || \
379 defined (L_umoddi3) || defined (L_moddi3))
380 static inline __attribute__ ((__always_inline__))
381 #endif
382 UWtype
__udiv_w_sdiv(UWtype * rp,UWtype a1,UWtype a0,UWtype d)383 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
384 {
385 UWtype q, r;
386 UWtype c0, c1, b1;
387
388 if ((Wtype) d >= 0)
389 {
390 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
391 {
392 /* dividend, divisor, and quotient are nonnegative */
393 sdiv_qrnnd (q, r, a1, a0, d);
394 }
395 else
396 {
397 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
398 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
399 /* Divide (c1*2^32 + c0) by d */
400 sdiv_qrnnd (q, r, c1, c0, d);
401 /* Add 2^31 to quotient */
402 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
403 }
404 }
405 else
406 {
407 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
408 c1 = a1 >> 1; /* A/2 */
409 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
410
411 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
412 {
413 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
414
415 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
416 if ((d & 1) != 0)
417 {
418 if (r >= q)
419 r = r - q;
420 else if (q - r <= d)
421 {
422 r = r - q + d;
423 q--;
424 }
425 else
426 {
427 r = r - q + 2*d;
428 q -= 2;
429 }
430 }
431 }
432 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
433 {
434 c1 = (b1 - 1) - c1;
435 c0 = ~c0; /* logical NOT */
436
437 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
438
439 q = ~q; /* (A/2)/b1 */
440 r = (b1 - 1) - r;
441
442 r = 2*r + (a0 & 1); /* A/(2*b1) */
443
444 if ((d & 1) != 0)
445 {
446 if (r >= q)
447 r = r - q;
448 else if (q - r <= d)
449 {
450 r = r - q + d;
451 q--;
452 }
453 else
454 {
455 r = r - q + 2*d;
456 q -= 2;
457 }
458 }
459 }
460 else /* Implies c1 = b1 */
461 { /* Hence a1 = d - 1 = 2*b1 - 1 */
462 if (a0 >= -d)
463 {
464 q = -1;
465 r = a0 + d;
466 }
467 else
468 {
469 q = -2;
470 r = a0 + 2*d;
471 }
472 }
473 }
474
475 *rp = r;
476 return q;
477 }
478 #else
479 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
480 UWtype
__udiv_w_sdiv(UWtype * rp,UWtype a1,UWtype a0,UWtype d)481 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
482 UWtype a1 __attribute__ ((__unused__)),
483 UWtype a0 __attribute__ ((__unused__)),
484 UWtype d __attribute__ ((__unused__)))
485 {
486 return 0;
487 }
488 #endif
489 #endif
490
491 #if (defined (L_udivdi3) || defined (L_divdi3) || \
492 defined (L_umoddi3) || defined (L_moddi3))
493 #define L_udivmoddi4
494 #endif
495
496 #ifdef L_clz
497 const UQItype __clz_tab[] =
498 {
499 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,
500 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,
501 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,
502 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,
503 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,
504 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,
505 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,
506 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,
507 };
508 #endif
509
510 #ifdef L_udivmoddi4
511
512 #if (defined (L_udivdi3) || defined (L_divdi3) || \
513 defined (L_umoddi3) || defined (L_moddi3))
514 static inline __attribute__ ((__always_inline__))
515 #endif
516 UDWtype
__udivmoddi4(UDWtype n,UDWtype d,UDWtype * rp)517 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
518 {
519 DWunion ww;
520 DWunion nn, dd;
521 DWunion rr;
522 UWtype d0, d1, n0, n1, n2;
523 UWtype q0, q1;
524 UWtype b, bm;
525
526 nn.ll = n;
527 dd.ll = d;
528
529 d0 = dd.s.low;
530 d1 = dd.s.high;
531 n0 = nn.s.low;
532 n1 = nn.s.high;
533
534 #if !UDIV_NEEDS_NORMALIZATION
535 if (d1 == 0)
536 {
537 if (d0 > n1)
538 {
539 /* 0q = nn / 0D */
540
541 udiv_qrnnd (q0, n0, n1, n0, d0);
542 q1 = 0;
543
544 /* Remainder in n0. */
545 }
546 else
547 {
548 /* qq = NN / 0d */
549
550 if (d0 == 0)
551 d0 = 1 / d0; /* Divide intentionally by zero. */
552
553 udiv_qrnnd (q1, n1, 0, n1, d0);
554 udiv_qrnnd (q0, n0, n1, n0, d0);
555
556 /* Remainder in n0. */
557 }
558
559 if (rp != 0)
560 {
561 rr.s.low = n0;
562 rr.s.high = 0;
563 *rp = rr.ll;
564 }
565 }
566
567 #else /* UDIV_NEEDS_NORMALIZATION */
568
569 if (d1 == 0)
570 {
571 if (d0 > n1)
572 {
573 /* 0q = nn / 0D */
574
575 count_leading_zeros (bm, d0);
576
577 if (bm != 0)
578 {
579 /* Normalize, i.e. make the most significant bit of the
580 denominator set. */
581
582 d0 = d0 << bm;
583 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
584 n0 = n0 << bm;
585 }
586
587 udiv_qrnnd (q0, n0, n1, n0, d0);
588 q1 = 0;
589
590 /* Remainder in n0 >> bm. */
591 }
592 else
593 {
594 /* qq = NN / 0d */
595
596 if (d0 == 0)
597 d0 = 1 / d0; /* Divide intentionally by zero. */
598
599 count_leading_zeros (bm, d0);
600
601 if (bm == 0)
602 {
603 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
604 conclude (the most significant bit of n1 is set) /\ (the
605 leading quotient digit q1 = 1).
606
607 This special case is necessary, not an optimization.
608 (Shifts counts of W_TYPE_SIZE are undefined.) */
609
610 n1 -= d0;
611 q1 = 1;
612 }
613 else
614 {
615 /* Normalize. */
616
617 b = W_TYPE_SIZE - bm;
618
619 d0 = d0 << bm;
620 n2 = n1 >> b;
621 n1 = (n1 << bm) | (n0 >> b);
622 n0 = n0 << bm;
623
624 udiv_qrnnd (q1, n1, n2, n1, d0);
625 }
626
627 /* n1 != d0... */
628
629 udiv_qrnnd (q0, n0, n1, n0, d0);
630
631 /* Remainder in n0 >> bm. */
632 }
633
634 if (rp != 0)
635 {
636 rr.s.low = n0 >> bm;
637 rr.s.high = 0;
638 *rp = rr.ll;
639 }
640 }
641 #endif /* UDIV_NEEDS_NORMALIZATION */
642
643 else
644 {
645 if (d1 > n1)
646 {
647 /* 00 = nn / DD */
648
649 q0 = 0;
650 q1 = 0;
651
652 /* Remainder in n1n0. */
653 if (rp != 0)
654 {
655 rr.s.low = n0;
656 rr.s.high = n1;
657 *rp = rr.ll;
658 }
659 }
660 else
661 {
662 /* 0q = NN / dd */
663
664 count_leading_zeros (bm, d1);
665 if (bm == 0)
666 {
667 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
668 conclude (the most significant bit of n1 is set) /\ (the
669 quotient digit q0 = 0 or 1).
670
671 This special case is necessary, not an optimization. */
672
673 /* The condition on the next line takes advantage of that
674 n1 >= d1 (true due to program flow). */
675 if (n1 > d1 || n0 >= d0)
676 {
677 q0 = 1;
678 sub_ddmmss (n1, n0, n1, n0, d1, d0);
679 }
680 else
681 q0 = 0;
682
683 q1 = 0;
684
685 if (rp != 0)
686 {
687 rr.s.low = n0;
688 rr.s.high = n1;
689 *rp = rr.ll;
690 }
691 }
692 else
693 {
694 UWtype m1, m0;
695 /* Normalize. */
696
697 b = W_TYPE_SIZE - bm;
698
699 d1 = (d1 << bm) | (d0 >> b);
700 d0 = d0 << bm;
701 n2 = n1 >> b;
702 n1 = (n1 << bm) | (n0 >> b);
703 n0 = n0 << bm;
704
705 udiv_qrnnd (q0, n1, n2, n1, d1);
706 umul_ppmm (m1, m0, q0, d0);
707
708 if (m1 > n1 || (m1 == n1 && m0 > n0))
709 {
710 q0--;
711 sub_ddmmss (m1, m0, m1, m0, d1, d0);
712 }
713
714 q1 = 0;
715
716 /* Remainder in (n1n0 - m1m0) >> bm. */
717 if (rp != 0)
718 {
719 sub_ddmmss (n1, n0, n1, n0, m1, m0);
720 rr.s.low = (n1 << b) | (n0 >> bm);
721 rr.s.high = n1 >> bm;
722 *rp = rr.ll;
723 }
724 }
725 }
726 }
727
728 ww.s.low = q0;
729 ww.s.high = q1;
730 return ww.ll;
731 }
732 #endif
733
734 #ifdef L_divdi3
735 DWtype
__divdi3(DWtype u,DWtype v)736 __divdi3 (DWtype u, DWtype v)
737 {
738 word_type c = 0;
739 DWunion uu, vv;
740 DWtype w;
741
742 uu.ll = u;
743 vv.ll = v;
744
745 if (uu.s.high < 0)
746 c = ~c,
747 uu.ll = -uu.ll;
748 if (vv.s.high < 0)
749 c = ~c,
750 vv.ll = -vv.ll;
751
752 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
753 if (c)
754 w = -w;
755
756 return w;
757 }
758 #endif
759
760 #ifdef L_moddi3
761 DWtype
__moddi3(DWtype u,DWtype v)762 __moddi3 (DWtype u, DWtype v)
763 {
764 word_type c = 0;
765 DWunion uu, vv;
766 DWtype w;
767
768 uu.ll = u;
769 vv.ll = v;
770
771 if (uu.s.high < 0)
772 c = ~c,
773 uu.ll = -uu.ll;
774 if (vv.s.high < 0)
775 vv.ll = -vv.ll;
776
777 (void) __udivmoddi4 (uu.ll, vv.ll, &w);
778 if (c)
779 w = -w;
780
781 return w;
782 }
783 #endif
784
785 #ifdef L_umoddi3
786 UDWtype
__umoddi3(UDWtype u,UDWtype v)787 __umoddi3 (UDWtype u, UDWtype v)
788 {
789 UDWtype w;
790
791 (void) __udivmoddi4 (u, v, &w);
792
793 return w;
794 }
795 #endif
796
797 #ifdef L_udivdi3
798 UDWtype
__udivdi3(UDWtype n,UDWtype d)799 __udivdi3 (UDWtype n, UDWtype d)
800 {
801 return __udivmoddi4 (n, d, (UDWtype *) 0);
802 }
803 #endif
804
805 #ifdef L_cmpdi2
806 word_type
__cmpdi2(DWtype a,DWtype b)807 __cmpdi2 (DWtype a, DWtype b)
808 {
809 DWunion au, bu;
810
811 au.ll = a, bu.ll = b;
812
813 if (au.s.high < bu.s.high)
814 return 0;
815 else if (au.s.high > bu.s.high)
816 return 2;
817 if ((UWtype) au.s.low < (UWtype) bu.s.low)
818 return 0;
819 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
820 return 2;
821 return 1;
822 }
823 #endif
824
825 #ifdef L_ucmpdi2
826 word_type
__ucmpdi2(DWtype a,DWtype b)827 __ucmpdi2 (DWtype a, DWtype b)
828 {
829 DWunion au, bu;
830
831 au.ll = a, bu.ll = b;
832
833 if ((UWtype) au.s.high < (UWtype) bu.s.high)
834 return 0;
835 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
836 return 2;
837 if ((UWtype) au.s.low < (UWtype) bu.s.low)
838 return 0;
839 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
840 return 2;
841 return 1;
842 }
843 #endif
844
845 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
846 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
847 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
848
849 DWtype
__fixunstfDI(TFtype a)850 __fixunstfDI (TFtype a)
851 {
852 TFtype b;
853 UDWtype v;
854
855 if (a < 0)
856 return 0;
857
858 /* Compute high word of result, as a flonum. */
859 b = (a / HIGH_WORD_COEFF);
860 /* Convert that to fixed (but not to DWtype!),
861 and shift it into the high word. */
862 v = (UWtype) b;
863 v <<= WORD_SIZE;
864 /* Remove high part from the TFtype, leaving the low part as flonum. */
865 a -= (TFtype)v;
866 /* Convert that to fixed (but not to DWtype!) and add it in.
867 Sometimes A comes out negative. This is significant, since
868 A has more bits than a long int does. */
869 if (a < 0)
870 v -= (UWtype) (- a);
871 else
872 v += (UWtype) a;
873 return v;
874 }
875 #endif
876
877 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
878 DWtype
__fixtfdi(TFtype a)879 __fixtfdi (TFtype a)
880 {
881 if (a < 0)
882 return - __fixunstfDI (-a);
883 return __fixunstfDI (a);
884 }
885 #endif
886
887 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
888 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
889 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
890
891 DWtype
__fixunsxfDI(XFtype a)892 __fixunsxfDI (XFtype a)
893 {
894 XFtype b;
895 UDWtype v;
896
897 if (a < 0)
898 return 0;
899
900 /* Compute high word of result, as a flonum. */
901 b = (a / HIGH_WORD_COEFF);
902 /* Convert that to fixed (but not to DWtype!),
903 and shift it into the high word. */
904 v = (UWtype) b;
905 v <<= WORD_SIZE;
906 /* Remove high part from the XFtype, leaving the low part as flonum. */
907 a -= (XFtype)v;
908 /* Convert that to fixed (but not to DWtype!) and add it in.
909 Sometimes A comes out negative. This is significant, since
910 A has more bits than a long int does. */
911 if (a < 0)
912 v -= (UWtype) (- a);
913 else
914 v += (UWtype) a;
915 return v;
916 }
917 #endif
918
919 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
920 DWtype
__fixxfdi(XFtype a)921 __fixxfdi (XFtype a)
922 {
923 if (a < 0)
924 return - __fixunsxfDI (-a);
925 return __fixunsxfDI (a);
926 }
927 #endif
928
929 #ifdef L_fixunsdfdi
930 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
931 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
932
933 DWtype
__fixunsdfDI(DFtype a)934 __fixunsdfDI (DFtype a)
935 {
936 DFtype b;
937 UDWtype v;
938
939 if (a < 0)
940 return 0;
941
942 /* Compute high word of result, as a flonum. */
943 b = (a / HIGH_WORD_COEFF);
944 /* Convert that to fixed (but not to DWtype!),
945 and shift it into the high word. */
946 v = (UWtype) b;
947 v <<= WORD_SIZE;
948 /* Remove high part from the DFtype, leaving the low part as flonum. */
949 a -= (DFtype)v;
950 /* Convert that to fixed (but not to DWtype!) and add it in.
951 Sometimes A comes out negative. This is significant, since
952 A has more bits than a long int does. */
953 if (a < 0)
954 v -= (UWtype) (- a);
955 else
956 v += (UWtype) a;
957 return v;
958 }
959 #endif
960
961 #ifdef L_fixdfdi
962 DWtype
__fixdfdi(DFtype a)963 __fixdfdi (DFtype a)
964 {
965 if (a < 0)
966 return - __fixunsdfDI (-a);
967 return __fixunsdfDI (a);
968 }
969 #endif
970
971 #ifdef L_fixunssfdi
972 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
973 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
974
975 DWtype
__fixunssfDI(SFtype original_a)976 __fixunssfDI (SFtype original_a)
977 {
978 /* Convert the SFtype to a DFtype, because that is surely not going
979 to lose any bits. Some day someone else can write a faster version
980 that avoids converting to DFtype, and verify it really works right. */
981 DFtype a = original_a;
982 DFtype b;
983 UDWtype v;
984
985 if (a < 0)
986 return 0;
987
988 /* Compute high word of result, as a flonum. */
989 b = (a / HIGH_WORD_COEFF);
990 /* Convert that to fixed (but not to DWtype!),
991 and shift it into the high word. */
992 v = (UWtype) b;
993 v <<= WORD_SIZE;
994 /* Remove high part from the DFtype, leaving the low part as flonum. */
995 a -= (DFtype) v;
996 /* Convert that to fixed (but not to DWtype!) and add it in.
997 Sometimes A comes out negative. This is significant, since
998 A has more bits than a long int does. */
999 if (a < 0)
1000 v -= (UWtype) (- a);
1001 else
1002 v += (UWtype) a;
1003 return v;
1004 }
1005 #endif
1006
1007 #ifdef L_fixsfdi
1008 DWtype
__fixsfdi(SFtype a)1009 __fixsfdi (SFtype a)
1010 {
1011 if (a < 0)
1012 return - __fixunssfDI (-a);
1013 return __fixunssfDI (a);
1014 }
1015 #endif
1016
1017 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1018 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1019 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1020 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1021
1022 XFtype
__floatdixf(DWtype u)1023 __floatdixf (DWtype u)
1024 {
1025 XFtype d;
1026
1027 d = (Wtype) (u >> WORD_SIZE);
1028 d *= HIGH_HALFWORD_COEFF;
1029 d *= HIGH_HALFWORD_COEFF;
1030 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1031
1032 return d;
1033 }
1034 #endif
1035
1036 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1037 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1038 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1039 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1040
1041 TFtype
__floatditf(DWtype u)1042 __floatditf (DWtype u)
1043 {
1044 TFtype d;
1045
1046 d = (Wtype) (u >> WORD_SIZE);
1047 d *= HIGH_HALFWORD_COEFF;
1048 d *= HIGH_HALFWORD_COEFF;
1049 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1050
1051 return d;
1052 }
1053 #endif
1054
1055 #ifdef L_floatdidf
1056 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1057 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1058 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1059
1060 DFtype
__floatdidf(DWtype u)1061 __floatdidf (DWtype u)
1062 {
1063 DFtype d;
1064
1065 d = (Wtype) (u >> WORD_SIZE);
1066 d *= HIGH_HALFWORD_COEFF;
1067 d *= HIGH_HALFWORD_COEFF;
1068 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1069
1070 return d;
1071 }
1072 #endif
1073
1074 #ifdef L_floatdisf
1075 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1076 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1077 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1078
1079 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1080 #define DF_SIZE DBL_MANT_DIG
1081 #define SF_SIZE FLT_MANT_DIG
1082
1083 SFtype
__floatdisf(DWtype u)1084 __floatdisf (DWtype u)
1085 {
1086 /* Do the calculation in DFmode
1087 so that we don't lose any of the precision of the high word
1088 while multiplying it. */
1089 DFtype f;
1090
1091 /* Protect against double-rounding error.
1092 Represent any low-order bits, that might be truncated in DFmode,
1093 by a bit that won't be lost. The bit can go in anywhere below the
1094 rounding position of the SFmode. A fixed mask and bit position
1095 handles all usual configurations. It doesn't handle the case
1096 of 128-bit DImode, however. */
1097 if (DF_SIZE < DI_SIZE
1098 && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1099 {
1100 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1101 if (! (- ((DWtype) 1 << DF_SIZE) < u
1102 && u < ((DWtype) 1 << DF_SIZE)))
1103 {
1104 if ((UDWtype) u & (REP_BIT - 1))
1105 {
1106 u &= ~ (REP_BIT - 1);
1107 u |= REP_BIT;
1108 }
1109 }
1110 }
1111 f = (Wtype) (u >> WORD_SIZE);
1112 f *= HIGH_HALFWORD_COEFF;
1113 f *= HIGH_HALFWORD_COEFF;
1114 f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1115
1116 return (SFtype) f;
1117 }
1118 #endif
1119
1120 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1121 /* Reenable the normal types, in case limits.h needs them. */
1122 #undef char
1123 #undef short
1124 #undef int
1125 #undef long
1126 #undef unsigned
1127 #undef float
1128 #undef double
1129 #undef MIN
1130 #undef MAX
1131 #include <limits.h>
1132
1133 UWtype
__fixunsxfSI(XFtype a)1134 __fixunsxfSI (XFtype a)
1135 {
1136 if (a >= - (DFtype) Wtype_MIN)
1137 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1138 return (Wtype) a;
1139 }
1140 #endif
1141
1142 #ifdef L_fixunsdfsi
1143 /* Reenable the normal types, in case limits.h needs them. */
1144 #undef char
1145 #undef short
1146 #undef int
1147 #undef long
1148 #undef unsigned
1149 #undef float
1150 #undef double
1151 #undef MIN
1152 #undef MAX
1153 #include <limits.h>
1154
1155 UWtype
__fixunsdfSI(DFtype a)1156 __fixunsdfSI (DFtype a)
1157 {
1158 if (a >= - (DFtype) Wtype_MIN)
1159 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1160 return (Wtype) a;
1161 }
1162 #endif
1163
1164 #ifdef L_fixunssfsi
1165 /* Reenable the normal types, in case limits.h needs them. */
1166 #undef char
1167 #undef short
1168 #undef int
1169 #undef long
1170 #undef unsigned
1171 #undef float
1172 #undef double
1173 #undef MIN
1174 #undef MAX
1175 #include <limits.h>
1176
1177 UWtype
__fixunssfSI(SFtype a)1178 __fixunssfSI (SFtype a)
1179 {
1180 if (a >= - (SFtype) Wtype_MIN)
1181 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1182 return (Wtype) a;
1183 }
1184 #endif
1185
1186 /* From here on down, the routines use normal data types. */
1187
1188 #define SItype bogus_type
1189 #define USItype bogus_type
1190 #define DItype bogus_type
1191 #define UDItype bogus_type
1192 #define SFtype bogus_type
1193 #define DFtype bogus_type
1194 #undef Wtype
1195 #undef UWtype
1196 #undef HWtype
1197 #undef UHWtype
1198 #undef DWtype
1199 #undef UDWtype
1200
1201 #undef char
1202 #undef short
1203 #undef int
1204 #undef long
1205 #undef unsigned
1206 #undef float
1207 #undef double
1208
1209 #ifdef L__gcc_bcmp
1210
1211 /* Like bcmp except the sign is meaningful.
1212 Result is negative if S1 is less than S2,
1213 positive if S1 is greater, 0 if S1 and S2 are equal. */
1214
1215 int
__gcc_bcmp(const unsigned char * s1,const unsigned char * s2,size_t size)1216 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1217 {
1218 while (size > 0)
1219 {
1220 unsigned char c1 = *s1++, c2 = *s2++;
1221 if (c1 != c2)
1222 return c1 - c2;
1223 size--;
1224 }
1225 return 0;
1226 }
1227
1228 #endif
1229
1230 /* __eprintf used to be used by GCC's private version of <assert.h>.
1231 We no longer provide that header, but this routine remains in libgcc.a
1232 for binary backward compatibility. Note that it is not included in
1233 the shared version of libgcc. */
1234 #ifdef L_eprintf
1235 #ifndef inhibit_libc
1236
1237 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1238 #include <stdio.h>
1239
1240 void
__eprintf(const char * string,const char * expression,unsigned int line,const char * filename)1241 __eprintf (const char *string, const char *expression,
1242 unsigned int line, const char *filename)
1243 {
1244 fprintf (stderr, string, expression, line, filename);
1245 fflush (stderr);
1246 abort ();
1247 }
1248
1249 #endif
1250 #endif
1251
1252 #ifdef L_bb
1253
1254 struct bb_function_info {
1255 long checksum;
1256 int arc_count;
1257 const char *name;
1258 };
1259
1260 /* Structure emitted by --profile-arcs */
1261 struct bb
1262 {
1263 long zero_word;
1264 const char *filename;
1265 gcov_type *counts;
1266 long ncounts;
1267 struct bb *next;
1268
1269 /* Older GCC's did not emit these fields. */
1270 long sizeof_bb;
1271 struct bb_function_info *function_infos;
1272 };
1273
1274 #ifndef inhibit_libc
1275
1276 /* Arc profile dumper. Requires atexit and stdio. */
1277
1278 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1279 #include <stdio.h>
1280
1281 #include "gcov-io.h"
1282 #include <string.h>
1283 #ifdef TARGET_HAS_F_SETLKW
1284 #include <fcntl.h>
1285 #include <errno.h>
1286 #endif
1287
1288 /* Chain of per-object file bb structures. */
1289 static struct bb *bb_head;
1290
1291 /* Dump the coverage counts. We merge with existing counts when
1292 possible, to avoid growing the .da files ad infinitum. */
1293
1294 void
__bb_exit_func(void)1295 __bb_exit_func (void)
1296 {
1297 struct bb *ptr;
1298 int i;
1299 gcov_type program_sum = 0;
1300 gcov_type program_max = 0;
1301 long program_arcs = 0;
1302 gcov_type merged_sum = 0;
1303 gcov_type merged_max = 0;
1304 long merged_arcs = 0;
1305
1306 #if defined (TARGET_HAS_F_SETLKW)
1307 struct flock s_flock;
1308
1309 s_flock.l_type = F_WRLCK;
1310 s_flock.l_whence = SEEK_SET;
1311 s_flock.l_start = 0;
1312 s_flock.l_len = 0; /* Until EOF. */
1313 s_flock.l_pid = getpid ();
1314 #endif
1315
1316 /* Non-merged stats for this program. */
1317 for (ptr = bb_head; ptr; ptr = ptr->next)
1318 {
1319 for (i = 0; i < ptr->ncounts; i++)
1320 {
1321 program_sum += ptr->counts[i];
1322
1323 if (ptr->counts[i] > program_max)
1324 program_max = ptr->counts[i];
1325 }
1326 program_arcs += ptr->ncounts;
1327 }
1328
1329 for (ptr = bb_head; ptr; ptr = ptr->next)
1330 {
1331 FILE *da_file;
1332 gcov_type object_max = 0;
1333 gcov_type object_sum = 0;
1334 long object_functions = 0;
1335 int merging = 0;
1336 int error = 0;
1337 struct bb_function_info *fn_info;
1338 gcov_type *count_ptr;
1339
1340 /* Open for modification */
1341 da_file = fopen (ptr->filename, "r+b");
1342
1343 if (da_file)
1344 merging = 1;
1345 else
1346 {
1347 /* Try for appending */
1348 da_file = fopen (ptr->filename, "ab");
1349 /* Some old systems might not allow the 'b' mode modifier.
1350 Therefore, try to open without it. This can lead to a
1351 race condition so that when you delete and re-create the
1352 file, the file might be opened in text mode, but then,
1353 you shouldn't delete the file in the first place. */
1354 if (!da_file)
1355 da_file = fopen (ptr->filename, "a");
1356 }
1357
1358 if (!da_file)
1359 {
1360 fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1361 ptr->filename);
1362 ptr->filename = 0;
1363 continue;
1364 }
1365
1366 #if defined (TARGET_HAS_F_SETLKW)
1367 /* After a fork, another process might try to read and/or write
1368 the same file simultanously. So if we can, lock the file to
1369 avoid race conditions. */
1370 while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1371 && errno == EINTR)
1372 continue;
1373 #endif
1374 for (fn_info = ptr->function_infos; fn_info->arc_count != -1; fn_info++)
1375 object_functions++;
1376
1377 if (merging)
1378 {
1379 /* Merge data from file. */
1380 long tmp_long;
1381 gcov_type tmp_gcov;
1382
1383 if (/* magic */
1384 (__read_long (&tmp_long, da_file, 4) || tmp_long != -123l)
1385 /* functions in object file. */
1386 || (__read_long (&tmp_long, da_file, 4)
1387 || tmp_long != object_functions)
1388 /* extension block, skipped */
1389 || (__read_long (&tmp_long, da_file, 4)
1390 || fseek (da_file, tmp_long, SEEK_CUR)))
1391 {
1392 read_error:;
1393 fprintf (stderr, "arc profiling: Error merging output file %s.\n",
1394 ptr->filename);
1395 clearerr (da_file);
1396 }
1397 else
1398 {
1399 /* Merge execution counts for each function. */
1400 count_ptr = ptr->counts;
1401
1402 for (fn_info = ptr->function_infos; fn_info->arc_count != -1;
1403 fn_info++)
1404 {
1405 if (/* function name delim */
1406 (__read_long (&tmp_long, da_file, 4)
1407 || tmp_long != -1)
1408 /* function name length */
1409 || (__read_long (&tmp_long, da_file, 4)
1410 || tmp_long != (long) strlen (fn_info->name))
1411 /* skip string */
1412 || fseek (da_file, ((tmp_long + 1) + 3) & ~3, SEEK_CUR)
1413 /* function name delim */
1414 || (__read_long (&tmp_long, da_file, 4)
1415 || tmp_long != -1))
1416 goto read_error;
1417
1418 if (/* function checksum */
1419 (__read_long (&tmp_long, da_file, 4)
1420 || tmp_long != fn_info->checksum)
1421 /* arc count */
1422 || (__read_long (&tmp_long, da_file, 4)
1423 || tmp_long != fn_info->arc_count))
1424 goto read_error;
1425
1426 for (i = fn_info->arc_count; i > 0; i--, count_ptr++)
1427 if (__read_gcov_type (&tmp_gcov, da_file, 8))
1428 goto read_error;
1429 else
1430 *count_ptr += tmp_gcov;
1431 }
1432 }
1433 fseek (da_file, 0, SEEK_SET);
1434 }
1435
1436 /* Calculate the per-object statistics. */
1437 for (i = 0; i < ptr->ncounts; i++)
1438 {
1439 object_sum += ptr->counts[i];
1440
1441 if (ptr->counts[i] > object_max)
1442 object_max = ptr->counts[i];
1443 }
1444 merged_sum += object_sum;
1445 if (merged_max < object_max)
1446 merged_max = object_max;
1447 merged_arcs += ptr->ncounts;
1448
1449 /* Write out the data. */
1450 if (/* magic */
1451 __write_long (-123, da_file, 4)
1452 /* number of functions in object file. */
1453 || __write_long (object_functions, da_file, 4)
1454 /* length of extra data in bytes. */
1455 || __write_long ((4 + 8 + 8) + (4 + 8 + 8), da_file, 4)
1456
1457 /* whole program statistics. If merging write per-object
1458 now, rewrite later */
1459 /* number of instrumented arcs. */
1460 || __write_long (merging ? ptr->ncounts : program_arcs, da_file, 4)
1461 /* sum of counters. */
1462 || __write_gcov_type (merging ? object_sum : program_sum, da_file, 8)
1463 /* maximal counter. */
1464 || __write_gcov_type (merging ? object_max : program_max, da_file, 8)
1465
1466 /* per-object statistics. */
1467 /* number of counters. */
1468 || __write_long (ptr->ncounts, da_file, 4)
1469 /* sum of counters. */
1470 || __write_gcov_type (object_sum, da_file, 8)
1471 /* maximal counter. */
1472 || __write_gcov_type (object_max, da_file, 8))
1473 {
1474 write_error:;
1475 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1476 ptr->filename);
1477 error = 1;
1478 }
1479 else
1480 {
1481 /* Write execution counts for each function. */
1482 count_ptr = ptr->counts;
1483
1484 for (fn_info = ptr->function_infos; fn_info->arc_count != -1;
1485 fn_info++)
1486 {
1487 if (__write_gcov_string (fn_info->name,
1488 strlen (fn_info->name), da_file, -1)
1489 || __write_long (fn_info->checksum, da_file, 4)
1490 || __write_long (fn_info->arc_count, da_file, 4))
1491 goto write_error;
1492
1493 for (i = fn_info->arc_count; i > 0; i--, count_ptr++)
1494 if (__write_gcov_type (*count_ptr, da_file, 8))
1495 goto write_error; /* RIP Edsger Dijkstra */
1496 }
1497 }
1498
1499 if (fclose (da_file))
1500 {
1501 fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1502 ptr->filename);
1503 error = 1;
1504 }
1505 if (error || !merging)
1506 ptr->filename = 0;
1507 }
1508
1509 /* Upate whole program statistics. */
1510 for (ptr = bb_head; ptr; ptr = ptr->next)
1511 if (ptr->filename)
1512 {
1513 FILE *da_file;
1514
1515 da_file = fopen (ptr->filename, "r+b");
1516 if (!da_file)
1517 {
1518 fprintf (stderr, "arc profiling: Cannot reopen %s.\n",
1519 ptr->filename);
1520 continue;
1521 }
1522
1523 #if defined (TARGET_HAS_F_SETLKW)
1524 while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1525 && errno == EINTR)
1526 continue;
1527 #endif
1528
1529 if (fseek (da_file, 4 * 3, SEEK_SET)
1530 /* number of instrumented arcs. */
1531 || __write_long (merged_arcs, da_file, 4)
1532 /* sum of counters. */
1533 || __write_gcov_type (merged_sum, da_file, 8)
1534 /* maximal counter. */
1535 || __write_gcov_type (merged_max, da_file, 8))
1536 fprintf (stderr, "arc profiling: Error updating program header %s.\n",
1537 ptr->filename);
1538 if (fclose (da_file))
1539 fprintf (stderr, "arc profiling: Error reclosing %s\n",
1540 ptr->filename);
1541 }
1542 }
1543
1544 /* Add a new object file onto the bb chain. Invoked automatically
1545 when running an object file's global ctors. */
1546
1547 void
__bb_init_func(struct bb * blocks)1548 __bb_init_func (struct bb *blocks)
1549 {
1550 if (blocks->zero_word)
1551 return;
1552
1553 /* Initialize destructor and per-thread data. */
1554 if (!bb_head)
1555 atexit (__bb_exit_func);
1556
1557 /* Set up linked list. */
1558 blocks->zero_word = 1;
1559 blocks->next = bb_head;
1560 bb_head = blocks;
1561 }
1562
1563 /* Called before fork or exec - write out profile information gathered so
1564 far and reset it to zero. This avoids duplication or loss of the
1565 profile information gathered so far. */
1566
1567 void
__bb_fork_func(void)1568 __bb_fork_func (void)
1569 {
1570 struct bb *ptr;
1571
1572 __bb_exit_func ();
1573 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1574 {
1575 long i;
1576 for (i = ptr->ncounts - 1; i >= 0; i--)
1577 ptr->counts[i] = 0;
1578 }
1579 }
1580
1581 #endif /* not inhibit_libc */
1582 #endif /* L_bb */
1583
1584 #ifdef L_clear_cache
1585 /* Clear part of an instruction cache. */
1586
1587 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1588
1589 void
__clear_cache(char * beg,char * end)1590 __clear_cache (char *beg __attribute__((__unused__)),
1591 char *end __attribute__((__unused__)))
1592 {
1593 #ifdef CLEAR_INSN_CACHE
1594 CLEAR_INSN_CACHE (beg, end);
1595 #else
1596 #ifdef INSN_CACHE_SIZE
1597 static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1598 static int initialized;
1599 int offset;
1600 void *start_addr
1601 void *end_addr;
1602 typedef (*function_ptr) (void);
1603
1604 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1605 /* It's cheaper to clear the whole cache.
1606 Put in a series of jump instructions so that calling the beginning
1607 of the cache will clear the whole thing. */
1608
1609 if (! initialized)
1610 {
1611 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1612 & -INSN_CACHE_LINE_WIDTH);
1613 int end_ptr = ptr + INSN_CACHE_SIZE;
1614
1615 while (ptr < end_ptr)
1616 {
1617 *(INSTRUCTION_TYPE *)ptr
1618 = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1619 ptr += INSN_CACHE_LINE_WIDTH;
1620 }
1621 *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1622
1623 initialized = 1;
1624 }
1625
1626 /* Call the beginning of the sequence. */
1627 (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1628 & -INSN_CACHE_LINE_WIDTH))
1629 ());
1630
1631 #else /* Cache is large. */
1632
1633 if (! initialized)
1634 {
1635 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1636 & -INSN_CACHE_LINE_WIDTH);
1637
1638 while (ptr < (int) array + sizeof array)
1639 {
1640 *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1641 ptr += INSN_CACHE_LINE_WIDTH;
1642 }
1643
1644 initialized = 1;
1645 }
1646
1647 /* Find the location in array that occupies the same cache line as BEG. */
1648
1649 offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1650 start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1651 & -INSN_CACHE_PLANE_SIZE)
1652 + offset);
1653
1654 /* Compute the cache alignment of the place to stop clearing. */
1655 #if 0 /* This is not needed for gcc's purposes. */
1656 /* If the block to clear is bigger than a cache plane,
1657 we clear the entire cache, and OFFSET is already correct. */
1658 if (end < beg + INSN_CACHE_PLANE_SIZE)
1659 #endif
1660 offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1661 & -INSN_CACHE_LINE_WIDTH)
1662 & (INSN_CACHE_PLANE_SIZE - 1));
1663
1664 #if INSN_CACHE_DEPTH > 1
1665 end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1666 if (end_addr <= start_addr)
1667 end_addr += INSN_CACHE_PLANE_SIZE;
1668
1669 for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1670 {
1671 int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1672 int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1673
1674 while (addr != stop)
1675 {
1676 /* Call the return instruction at ADDR. */
1677 ((function_ptr) addr) ();
1678
1679 addr += INSN_CACHE_LINE_WIDTH;
1680 }
1681 }
1682 #else /* just one plane */
1683 do
1684 {
1685 /* Call the return instruction at START_ADDR. */
1686 ((function_ptr) start_addr) ();
1687
1688 start_addr += INSN_CACHE_LINE_WIDTH;
1689 }
1690 while ((start_addr % INSN_CACHE_SIZE) != offset);
1691 #endif /* just one plane */
1692 #endif /* Cache is large */
1693 #endif /* Cache exists */
1694 #endif /* CLEAR_INSN_CACHE */
1695 }
1696
1697 #endif /* L_clear_cache */
1698
1699 #ifdef L_trampoline
1700
1701 /* Jump to a trampoline, loading the static chain address. */
1702
1703 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1704
1705 long
getpagesize(void)1706 getpagesize (void)
1707 {
1708 #ifdef _ALPHA_
1709 return 8192;
1710 #else
1711 return 4096;
1712 #endif
1713 }
1714
1715 #ifdef __i386__
1716 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1717 #endif
1718
1719 int
mprotect(char * addr,int len,int prot)1720 mprotect (char *addr, int len, int prot)
1721 {
1722 int np, op;
1723
1724 if (prot == 7)
1725 np = 0x40;
1726 else if (prot == 5)
1727 np = 0x20;
1728 else if (prot == 4)
1729 np = 0x10;
1730 else if (prot == 3)
1731 np = 0x04;
1732 else if (prot == 1)
1733 np = 0x02;
1734 else if (prot == 0)
1735 np = 0x01;
1736
1737 if (VirtualProtect (addr, len, np, &op))
1738 return 0;
1739 else
1740 return -1;
1741 }
1742
1743 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1744
1745 #ifdef TRANSFER_FROM_TRAMPOLINE
1746 TRANSFER_FROM_TRAMPOLINE
1747 #endif
1748
1749 #ifdef __sysV68__
1750
1751 #include <sys/signal.h>
1752 #include <errno.h>
1753
1754 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1755 so define it here, because we need it in __clear_insn_cache below */
1756 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1757 hence we enable this stuff only if MCT_TEXT is #define'd. */
1758
1759 #ifdef MCT_TEXT
1760 asm("\n\
1761 global memctl\n\
1762 memctl:\n\
1763 movq &75,%d0\n\
1764 trap &0\n\
1765 bcc.b noerror\n\
1766 jmp cerror%\n\
1767 noerror:\n\
1768 movq &0,%d0\n\
1769 rts");
1770 #endif
1771
1772 /* Clear instruction cache so we can call trampolines on stack.
1773 This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
1774
1775 void
__clear_insn_cache(void)1776 __clear_insn_cache (void)
1777 {
1778 #ifdef MCT_TEXT
1779 int save_errno;
1780
1781 /* Preserve errno, because users would be surprised to have
1782 errno changing without explicitly calling any system-call. */
1783 save_errno = errno;
1784
1785 /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1786 No need to use an address derived from _start or %sp, as 0 works also. */
1787 memctl(0, 4096, MCT_TEXT);
1788 errno = save_errno;
1789 #endif
1790 }
1791
1792 #endif /* __sysV68__ */
1793 #endif /* L_trampoline */
1794
1795 #ifndef __CYGWIN__
1796 #ifdef L__main
1797
1798 #include "gbl-ctors.h"
1799 /* Some systems use __main in a way incompatible with its use in gcc, in these
1800 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1801 give the same symbol without quotes for an alternative entry point. You
1802 must define both, or neither. */
1803 #ifndef NAME__MAIN
1804 #define NAME__MAIN "__main"
1805 #define SYMBOL__MAIN __main
1806 #endif
1807
1808 #ifdef INIT_SECTION_ASM_OP
1809 #undef HAS_INIT_SECTION
1810 #define HAS_INIT_SECTION
1811 #endif
1812
1813 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1814
1815 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1816 code to run constructors. In that case, we need to handle EH here, too. */
1817
1818 #ifdef EH_FRAME_SECTION_NAME
1819 #include "unwind-dw2-fde.h"
1820 extern unsigned char __EH_FRAME_BEGIN__[];
1821 #endif
1822
1823 /* Run all the global destructors on exit from the program. */
1824
1825 void
__do_global_dtors(void)1826 __do_global_dtors (void)
1827 {
1828 #ifdef DO_GLOBAL_DTORS_BODY
1829 DO_GLOBAL_DTORS_BODY;
1830 #else
1831 static func_ptr *p = __DTOR_LIST__ + 1;
1832 while (*p)
1833 {
1834 p++;
1835 (*(p-1)) ();
1836 }
1837 #endif
1838 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1839 {
1840 static int completed = 0;
1841 if (! completed)
1842 {
1843 completed = 1;
1844 __deregister_frame_info (__EH_FRAME_BEGIN__);
1845 }
1846 }
1847 #endif
1848 }
1849 #endif
1850
1851 #ifndef HAS_INIT_SECTION
1852 /* Run all the global constructors on entry to the program. */
1853
1854 void
__do_global_ctors(void)1855 __do_global_ctors (void)
1856 {
1857 #ifdef EH_FRAME_SECTION_NAME
1858 {
1859 static struct object object;
1860 __register_frame_info (__EH_FRAME_BEGIN__, &object);
1861 }
1862 #endif
1863 DO_GLOBAL_CTORS_BODY;
1864 atexit (__do_global_dtors);
1865 }
1866 #endif /* no HAS_INIT_SECTION */
1867
1868 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1869 /* Subroutine called automatically by `main'.
1870 Compiling a global function named `main'
1871 produces an automatic call to this function at the beginning.
1872
1873 For many systems, this routine calls __do_global_ctors.
1874 For systems which support a .init section we use the .init section
1875 to run __do_global_ctors, so we need not do anything here. */
1876
1877 void
SYMBOL__MAIN()1878 SYMBOL__MAIN ()
1879 {
1880 /* Support recursive calls to `main': run initializers just once. */
1881 static int initialized;
1882 if (! initialized)
1883 {
1884 initialized = 1;
1885 __do_global_ctors ();
1886 }
1887 }
1888 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1889
1890 #endif /* L__main */
1891 #endif /* __CYGWIN__ */
1892
1893 #ifdef L_ctors
1894
1895 #include "gbl-ctors.h"
1896
1897 /* Provide default definitions for the lists of constructors and
1898 destructors, so that we don't get linker errors. These symbols are
1899 intentionally bss symbols, so that gld and/or collect will provide
1900 the right values. */
1901
1902 /* We declare the lists here with two elements each,
1903 so that they are valid empty lists if no other definition is loaded.
1904
1905 If we are using the old "set" extensions to have the gnu linker
1906 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
1907 must be in the bss/common section.
1908
1909 Long term no port should use those extensions. But many still do. */
1910 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1911 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
1912 func_ptr __CTOR_LIST__[2] = {0, 0};
1913 func_ptr __DTOR_LIST__[2] = {0, 0};
1914 #else
1915 func_ptr __CTOR_LIST__[2];
1916 func_ptr __DTOR_LIST__[2];
1917 #endif
1918 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1919 #endif /* L_ctors */
1920
1921 #ifdef L_exit
1922
1923 #include "gbl-ctors.h"
1924
1925 #ifdef NEED_ATEXIT
1926
1927 #ifndef ON_EXIT
1928
1929 # include <errno.h>
1930
1931 static func_ptr *atexit_chain = 0;
1932 static long atexit_chain_length = 0;
1933 static volatile long last_atexit_chain_slot = -1;
1934
1935 int
atexit(func_ptr func)1936 atexit (func_ptr func)
1937 {
1938 if (++last_atexit_chain_slot == atexit_chain_length)
1939 {
1940 atexit_chain_length += 32;
1941 if (atexit_chain)
1942 atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
1943 * sizeof (func_ptr));
1944 else
1945 atexit_chain = (func_ptr *) malloc (atexit_chain_length
1946 * sizeof (func_ptr));
1947 if (! atexit_chain)
1948 {
1949 atexit_chain_length = 0;
1950 last_atexit_chain_slot = -1;
1951 errno = ENOMEM;
1952 return (-1);
1953 }
1954 }
1955 atexit_chain[last_atexit_chain_slot] = func;
1956 return (0);
1957 }
1958
1959 extern void _cleanup (void);
1960 extern void _exit (int) __attribute__ ((__noreturn__));
1961
1962 void
exit(int status)1963 exit (int status)
1964 {
1965 if (atexit_chain)
1966 {
1967 for ( ; last_atexit_chain_slot-- >= 0; )
1968 {
1969 (*atexit_chain[last_atexit_chain_slot + 1]) ();
1970 atexit_chain[last_atexit_chain_slot + 1] = 0;
1971 }
1972 free (atexit_chain);
1973 atexit_chain = 0;
1974 }
1975 #ifdef EXIT_BODY
1976 EXIT_BODY;
1977 #else
1978 _cleanup ();
1979 #endif
1980 _exit (status);
1981 }
1982
1983 #else /* ON_EXIT */
1984
1985 /* Simple; we just need a wrapper for ON_EXIT. */
1986 int
atexit(func_ptr func)1987 atexit (func_ptr func)
1988 {
1989 return ON_EXIT (func);
1990 }
1991
1992 #endif /* ON_EXIT */
1993 #endif /* NEED_ATEXIT */
1994
1995 #endif /* L_exit */
1996