?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* c-common.c (check_function_format): Don't suggest adding format
[official-gcc.git] / gcc / libgcc2.c
blob6d49f377feeb9a33b886cf687ee7662a1abbacda
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, 2000
4 Free Software Foundation, Inc.
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later 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 GNU CC is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with GNU CC; see the file COPYING. If not, write to
29 the Free Software Foundation, 59 Temple Place - Suite 330,
30 Boston, MA 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 #include "machmode.h"
40 #include "defaults.h"
41
42 /* Don't use `fancy_abort' here even if config.h says to use it. */
43 #ifdef abort
44 #undef abort
45 #endif
46
47 #include "libgcc2.h"
48 \f
49 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
50 #if defined (L_divdi3) || defined (L_moddi3)
51 static inline
52 #endif
53 DWtype
54 __negdi2 (DWtype u)
55 {
56 DWunion w;
57 DWunion uu;
58
59 uu.ll = u;
60
61 w.s.low = -uu.s.low;
62 w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
63
64 return w.ll;
65 }
66 #endif
67
68 #ifdef L_addvsi3
69 SItype
70 __addvsi3 (SItype a, SItype b)
71 {
72 SItype w;
73
74 w = a + b;
75
76 if (b >= 0 ? w < a : w > a)
77 abort ();
78
79 return w;
80 }
81 #endif
82 \f
83 #ifdef L_addvdi3
84 DItype
85 __addvdi3 (DItype a, DItype b)
86 {
87 DItype w;
88
89 w = a + b;
90
91 if (b >= 0 ? w < a : w > a)
92 abort ();
93
94 return w;
95 }
96 #endif
97 \f
98 #ifdef L_subvsi3
99 SItype
100 __subvsi3 (SItype a, SItype b)
101 {
102 #ifdef L_addvsi3
103 return __addvsi3 (a, (-b));
104 #else
105 DItype w;
106
107 w = a - b;
108
109 if (b >= 0 ? w > a : w < a)
110 abort ();
111
112 return w;
113 #endif
114 }
115 #endif
116 \f
117 #ifdef L_subvdi3
118 DItype
119 __subvdi3 (DItype a, DItype b)
120 {
121 #ifdef L_addvdi3
122 return (a, (-b));
123 #else
124 DItype w;
125
126 w = a - b;
127
128 if (b >= 0 ? w > a : w < a)
129 abort ();
130
131 return w;
132 #endif
133 }
134 #endif
135 \f
136 #ifdef L_mulvsi3
137 SItype
138 __mulvsi3 (SItype a, SItype b)
139 {
140 DItype w;
141
142 w = a * b;
143
144 if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
145 abort ();
146
147 return w;
148 }
149 #endif
150 \f
151 #ifdef L_negvsi2
152 SItype
153 __negvsi2 (SItype a)
154 {
155 SItype w;
156
157 w = -a;
158
159 if (a >= 0 ? w > 0 : w < 0)
160 abort ();
161
162 return w;
163 }
164 #endif
165 \f
166 #ifdef L_negvdi2
167 DItype
168 __negvdi2 (DItype a)
169 {
170 DItype w;
171
172 w = -a;
173
174 if (a >= 0 ? w > 0 : w < 0)
175 abort ();
176
177 return w;
178 }
179 #endif
180 \f
181 #ifdef L_absvsi2
182 SItype
183 __absvsi2 (SItype a)
184 {
185 SItype w = a;
186
187 if (a < 0)
188 #ifdef L_negvsi2
189 w = __negvsi2 (a);
190 #else
191 w = -a;
192
193 if (w < 0)
194 abort ();
195 #endif
196
197 return w;
198 }
199 #endif
200 \f
201 #ifdef L_absvdi2
202 DItype
203 __absvdi2 (DItype a)
204 {
205 DItype w = a;
206
207 if (a < 0)
208 #ifdef L_negvsi2
209 w = __negvsi2 (a);
210 #else
211 w = -a;
212
213 if (w < 0)
214 abort ();
215 #endif
216
217 return w;
218 }
219 #endif
220 \f
221 #ifdef L_mulvdi3
222 DItype
223 __mulvdi3 (DItype u, DItype v)
224 {
225 DItype w;
226
227 w = u * v;
228
229 if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
230 abort ();
231
232 return w;
233 }
234 #endif
235 \f
236
237 /* Unless shift functions are defined whith full ANSI prototypes,
238 parameter b will be promoted to int if word_type is smaller than an int. */
239 #ifdef L_lshrdi3
240 DWtype
241 __lshrdi3 (DWtype u, word_type b)
242 {
243 DWunion w;
244 word_type bm;
245 DWunion uu;
246
247 if (b == 0)
248 return u;
249
250 uu.ll = u;
251
252 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
253 if (bm <= 0)
254 {
255 w.s.high = 0;
256 w.s.low = (UWtype) uu.s.high >> -bm;
257 }
258 else
259 {
260 UWtype carries = (UWtype) uu.s.high << bm;
261
262 w.s.high = (UWtype) uu.s.high >> b;
263 w.s.low = ((UWtype) uu.s.low >> b) | carries;
264 }
265
266 return w.ll;
267 }
268 #endif
269
270 #ifdef L_ashldi3
271 DWtype
272 __ashldi3 (DWtype u, word_type b)
273 {
274 DWunion w;
275 word_type bm;
276 DWunion uu;
277
278 if (b == 0)
279 return u;
280
281 uu.ll = u;
282
283 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
284 if (bm <= 0)
285 {
286 w.s.low = 0;
287 w.s.high = (UWtype) uu.s.low << -bm;
288 }
289 else
290 {
291 UWtype carries = (UWtype) uu.s.low >> bm;
292
293 w.s.low = (UWtype) uu.s.low << b;
294 w.s.high = ((UWtype) uu.s.high << b) | carries;
295 }
296
297 return w.ll;
298 }
299 #endif
300
301 #ifdef L_ashrdi3
302 DWtype
303 __ashrdi3 (DWtype u, word_type b)
304 {
305 DWunion w;
306 word_type bm;
307 DWunion uu;
308
309 if (b == 0)
310 return u;
311
312 uu.ll = u;
313
314 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
315 if (bm <= 0)
316 {
317 /* w.s.high = 1..1 or 0..0 */
318 w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
319 w.s.low = uu.s.high >> -bm;
320 }
321 else
322 {
323 UWtype carries = (UWtype) uu.s.high << bm;
324
325 w.s.high = uu.s.high >> b;
326 w.s.low = ((UWtype) uu.s.low >> b) | carries;
327 }
328
329 return w.ll;
330 }
331 #endif
332 \f
333 #ifdef L_ffsdi2
334 DWtype
335 __ffsdi2 (DWtype u)
336 {
337 DWunion uu;
338 UWtype word, count, add;
339
340 uu.ll = u;
341 if (uu.s.low != 0)
342 word = uu.s.low, add = 0;
343 else if (uu.s.high != 0)
344 word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
345 else
346 return 0;
347
348 count_trailing_zeros (count, word);
349 return count + add + 1;
350 }
351 #endif
352 \f
353 #ifdef L_muldi3
354 DWtype
355 __muldi3 (DWtype u, DWtype v)
356 {
357 DWunion w;
358 DWunion uu, vv;
359
360 uu.ll = u,
361 vv.ll = v;
362
363 w.ll = __umulsidi3 (uu.s.low, vv.s.low);
364 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
365 + (UWtype) uu.s.high * (UWtype) vv.s.low);
366
367 return w.ll;
368 }
369 #endif
370 \f
371 #ifdef L_udiv_w_sdiv
372 #if defined (sdiv_qrnnd)
373 UWtype
374 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
375 {
376 UWtype q, r;
377 UWtype c0, c1, b1;
378
379 if ((Wtype) d >= 0)
380 {
381 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
382 {
383 /* dividend, divisor, and quotient are nonnegative */
384 sdiv_qrnnd (q, r, a1, a0, d);
385 }
386 else
387 {
388 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
389 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
390 /* Divide (c1*2^32 + c0) by d */
391 sdiv_qrnnd (q, r, c1, c0, d);
392 /* Add 2^31 to quotient */
393 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
394 }
395 }
396 else
397 {
398 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
399 c1 = a1 >> 1; /* A/2 */
400 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
401
402 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
403 {
404 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
405
406 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
407 if ((d & 1) != 0)
408 {
409 if (r >= q)
410 r = r - q;
411 else if (q - r <= d)
412 {
413 r = r - q + d;
414 q--;
415 }
416 else
417 {
418 r = r - q + 2*d;
419 q -= 2;
420 }
421 }
422 }
423 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
424 {
425 c1 = (b1 - 1) - c1;
426 c0 = ~c0; /* logical NOT */
427
428 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
429
430 q = ~q; /* (A/2)/b1 */
431 r = (b1 - 1) - r;
432
433 r = 2*r + (a0 & 1); /* A/(2*b1) */
434
435 if ((d & 1) != 0)
436 {
437 if (r >= q)
438 r = r - q;
439 else if (q - r <= d)
440 {
441 r = r - q + d;
442 q--;
443 }
444 else
445 {
446 r = r - q + 2*d;
447 q -= 2;
448 }
449 }
450 }
451 else /* Implies c1 = b1 */
452 { /* Hence a1 = d - 1 = 2*b1 - 1 */
453 if (a0 >= -d)
454 {
455 q = -1;
456 r = a0 + d;
457 }
458 else
459 {
460 q = -2;
461 r = a0 + 2*d;
462 }
463 }
464 }
465
466 *rp = r;
467 return q;
468 }
469 #else
470 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
471 UWtype
472 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
473 UWtype a1 __attribute__ ((__unused__)),
474 UWtype a0 __attribute__ ((__unused__)),
475 UWtype d __attribute__ ((__unused__)))
476 {
477 return 0;
478 }
479 #endif
480 #endif
481 \f
482 #if (defined (L_udivdi3) || defined (L_divdi3) || \
483 defined (L_umoddi3) || defined (L_moddi3))
484 #define L_udivmoddi4
485 #endif
486
487 #ifdef L_clz
488 const UQItype __clz_tab[] =
489 {
490 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,
491 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,
492 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,
493 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,
494 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,
495 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,
496 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,
497 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,
498 };
499 #endif
500
501 #ifdef L_udivmoddi4
502
503 #if (defined (L_udivdi3) || defined (L_divdi3) || \
504 defined (L_umoddi3) || defined (L_moddi3))
505 static inline
506 #endif
507 UDWtype
508 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
509 {
510 DWunion ww;
511 DWunion nn, dd;
512 DWunion rr;
513 UWtype d0, d1, n0, n1, n2;
514 UWtype q0, q1;
515 UWtype b, bm;
516
517 nn.ll = n;
518 dd.ll = d;
519
520 d0 = dd.s.low;
521 d1 = dd.s.high;
522 n0 = nn.s.low;
523 n1 = nn.s.high;
524
525 #if !UDIV_NEEDS_NORMALIZATION
526 if (d1 == 0)
527 {
528 if (d0 > n1)
529 {
530 /* 0q = nn / 0D */
531
532 udiv_qrnnd (q0, n0, n1, n0, d0);
533 q1 = 0;
534
535 /* Remainder in n0. */
536 }
537 else
538 {
539 /* qq = NN / 0d */
540
541 if (d0 == 0)
542 d0 = 1 / d0; /* Divide intentionally by zero. */
543
544 udiv_qrnnd (q1, n1, 0, n1, d0);
545 udiv_qrnnd (q0, n0, n1, n0, d0);
546
547 /* Remainder in n0. */
548 }
549
550 if (rp != 0)
551 {
552 rr.s.low = n0;
553 rr.s.high = 0;
554 *rp = rr.ll;
555 }
556 }
557
558 #else /* UDIV_NEEDS_NORMALIZATION */
559
560 if (d1 == 0)
561 {
562 if (d0 > n1)
563 {
564 /* 0q = nn / 0D */
565
566 count_leading_zeros (bm, d0);
567
568 if (bm != 0)
569 {
570 /* Normalize, i.e. make the most significant bit of the
571 denominator set. */
572
573 d0 = d0 << bm;
574 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
575 n0 = n0 << bm;
576 }
577
578 udiv_qrnnd (q0, n0, n1, n0, d0);
579 q1 = 0;
580
581 /* Remainder in n0 >> bm. */
582 }
583 else
584 {
585 /* qq = NN / 0d */
586
587 if (d0 == 0)
588 d0 = 1 / d0; /* Divide intentionally by zero. */
589
590 count_leading_zeros (bm, d0);
591
592 if (bm == 0)
593 {
594 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
595 conclude (the most significant bit of n1 is set) /\ (the
596 leading quotient digit q1 = 1).
597
598 This special case is necessary, not an optimization.
599 (Shifts counts of W_TYPE_SIZE are undefined.) */
600
601 n1 -= d0;
602 q1 = 1;
603 }
604 else
605 {
606 /* Normalize. */
607
608 b = W_TYPE_SIZE - bm;
609
610 d0 = d0 << bm;
611 n2 = n1 >> b;
612 n1 = (n1 << bm) | (n0 >> b);
613 n0 = n0 << bm;
614
615 udiv_qrnnd (q1, n1, n2, n1, d0);
616 }
617
618 /* n1 != d0... */
619
620 udiv_qrnnd (q0, n0, n1, n0, d0);
621
622 /* Remainder in n0 >> bm. */
623 }
624
625 if (rp != 0)
626 {
627 rr.s.low = n0 >> bm;
628 rr.s.high = 0;
629 *rp = rr.ll;
630 }
631 }
632 #endif /* UDIV_NEEDS_NORMALIZATION */
633
634 else
635 {
636 if (d1 > n1)
637 {
638 /* 00 = nn / DD */
639
640 q0 = 0;
641 q1 = 0;
642
643 /* Remainder in n1n0. */
644 if (rp != 0)
645 {
646 rr.s.low = n0;
647 rr.s.high = n1;
648 *rp = rr.ll;
649 }
650 }
651 else
652 {
653 /* 0q = NN / dd */
654
655 count_leading_zeros (bm, d1);
656 if (bm == 0)
657 {
658 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
659 conclude (the most significant bit of n1 is set) /\ (the
660 quotient digit q0 = 0 or 1).
661
662 This special case is necessary, not an optimization. */
663
664 /* The condition on the next line takes advantage of that
665 n1 >= d1 (true due to program flow). */
666 if (n1 > d1 || n0 >= d0)
667 {
668 q0 = 1;
669 sub_ddmmss (n1, n0, n1, n0, d1, d0);
670 }
671 else
672 q0 = 0;
673
674 q1 = 0;
675
676 if (rp != 0)
677 {
678 rr.s.low = n0;
679 rr.s.high = n1;
680 *rp = rr.ll;
681 }
682 }
683 else
684 {
685 UWtype m1, m0;
686 /* Normalize. */
687
688 b = W_TYPE_SIZE - bm;
689
690 d1 = (d1 << bm) | (d0 >> b);
691 d0 = d0 << bm;
692 n2 = n1 >> b;
693 n1 = (n1 << bm) | (n0 >> b);
694 n0 = n0 << bm;
695
696 udiv_qrnnd (q0, n1, n2, n1, d1);
697 umul_ppmm (m1, m0, q0, d0);
698
699 if (m1 > n1 || (m1 == n1 && m0 > n0))
700 {
701 q0--;
702 sub_ddmmss (m1, m0, m1, m0, d1, d0);
703 }
704
705 q1 = 0;
706
707 /* Remainder in (n1n0 - m1m0) >> bm. */
708 if (rp != 0)
709 {
710 sub_ddmmss (n1, n0, n1, n0, m1, m0);
711 rr.s.low = (n1 << b) | (n0 >> bm);
712 rr.s.high = n1 >> bm;
713 *rp = rr.ll;
714 }
715 }
716 }
717 }
718
719 ww.s.low = q0;
720 ww.s.high = q1;
721 return ww.ll;
722 }
723 #endif
724
725 #ifdef L_divdi3
726 DWtype
727 __divdi3 (DWtype u, DWtype v)
728 {
729 word_type c = 0;
730 DWunion uu, vv;
731 DWtype w;
732
733 uu.ll = u;
734 vv.ll = v;
735
736 if (uu.s.high < 0)
737 c = ~c,
738 uu.ll = __negdi2 (uu.ll);
739 if (vv.s.high < 0)
740 c = ~c,
741 vv.ll = __negdi2 (vv.ll);
742
743 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
744 if (c)
745 w = __negdi2 (w);
746
747 return w;
748 }
749 #endif
750
751 #ifdef L_moddi3
752 DWtype
753 __moddi3 (DWtype u, DWtype v)
754 {
755 word_type c = 0;
756 DWunion uu, vv;
757 DWtype w;
758
759 uu.ll = u;
760 vv.ll = v;
761
762 if (uu.s.high < 0)
763 c = ~c,
764 uu.ll = __negdi2 (uu.ll);
765 if (vv.s.high < 0)
766 vv.ll = __negdi2 (vv.ll);
767
768 (void) __udivmoddi4 (uu.ll, vv.ll, &w);
769 if (c)
770 w = __negdi2 (w);
771
772 return w;
773 }
774 #endif
775
776 #ifdef L_umoddi3
777 UDWtype
778 __umoddi3 (UDWtype u, UDWtype v)
779 {
780 UDWtype w;
781
782 (void) __udivmoddi4 (u, v, &w);
783
784 return w;
785 }
786 #endif
787
788 #ifdef L_udivdi3
789 UDWtype
790 __udivdi3 (UDWtype n, UDWtype d)
791 {
792 return __udivmoddi4 (n, d, (UDWtype *) 0);
793 }
794 #endif
795 \f
796 #ifdef L_cmpdi2
797 word_type
798 __cmpdi2 (DWtype a, DWtype b)
799 {
800 DWunion au, bu;
801
802 au.ll = a, bu.ll = b;
803
804 if (au.s.high < bu.s.high)
805 return 0;
806 else if (au.s.high > bu.s.high)
807 return 2;
808 if ((UWtype) au.s.low < (UWtype) bu.s.low)
809 return 0;
810 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
811 return 2;
812 return 1;
813 }
814 #endif
815
816 #ifdef L_ucmpdi2
817 word_type
818 __ucmpdi2 (DWtype a, DWtype b)
819 {
820 DWunion au, bu;
821
822 au.ll = a, bu.ll = b;
823
824 if ((UWtype) au.s.high < (UWtype) bu.s.high)
825 return 0;
826 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
827 return 2;
828 if ((UWtype) au.s.low < (UWtype) bu.s.low)
829 return 0;
830 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
831 return 2;
832 return 1;
833 }
834 #endif
835 \f
836 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
837 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
838 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
839
840 DWtype
841 __fixunstfDI (TFtype a)
842 {
843 TFtype b;
844 UDWtype v;
845
846 if (a < 0)
847 return 0;
848
849 /* Compute high word of result, as a flonum. */
850 b = (a / HIGH_WORD_COEFF);
851 /* Convert that to fixed (but not to DWtype!),
852 and shift it into the high word. */
853 v = (UWtype) b;
854 v <<= WORD_SIZE;
855 /* Remove high part from the TFtype, leaving the low part as flonum. */
856 a -= (TFtype)v;
857 /* Convert that to fixed (but not to DWtype!) and add it in.
858 Sometimes A comes out negative. This is significant, since
859 A has more bits than a long int does. */
860 if (a < 0)
861 v -= (UWtype) (- a);
862 else
863 v += (UWtype) a;
864 return v;
865 }
866 #endif
867
868 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
869 DWtype
870 __fixtfdi (TFtype a)
871 {
872 if (a < 0)
873 return - __fixunstfDI (-a);
874 return __fixunstfDI (a);
875 }
876 #endif
877
878 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
879 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
880 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
881
882 DWtype
883 __fixunsxfDI (XFtype a)
884 {
885 XFtype b;
886 UDWtype v;
887
888 if (a < 0)
889 return 0;
890
891 /* Compute high word of result, as a flonum. */
892 b = (a / HIGH_WORD_COEFF);
893 /* Convert that to fixed (but not to DWtype!),
894 and shift it into the high word. */
895 v = (UWtype) b;
896 v <<= WORD_SIZE;
897 /* Remove high part from the XFtype, leaving the low part as flonum. */
898 a -= (XFtype)v;
899 /* Convert that to fixed (but not to DWtype!) and add it in.
900 Sometimes A comes out negative. This is significant, since
901 A has more bits than a long int does. */
902 if (a < 0)
903 v -= (UWtype) (- a);
904 else
905 v += (UWtype) a;
906 return v;
907 }
908 #endif
909
910 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
911 DWtype
912 __fixxfdi (XFtype a)
913 {
914 if (a < 0)
915 return - __fixunsxfDI (-a);
916 return __fixunsxfDI (a);
917 }
918 #endif
919
920 #ifdef L_fixunsdfdi
921 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
922 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
923
924 DWtype
925 __fixunsdfDI (DFtype a)
926 {
927 DFtype b;
928 UDWtype v;
929
930 if (a < 0)
931 return 0;
932
933 /* Compute high word of result, as a flonum. */
934 b = (a / HIGH_WORD_COEFF);
935 /* Convert that to fixed (but not to DWtype!),
936 and shift it into the high word. */
937 v = (UWtype) b;
938 v <<= WORD_SIZE;
939 /* Remove high part from the DFtype, leaving the low part as flonum. */
940 a -= (DFtype)v;
941 /* Convert that to fixed (but not to DWtype!) and add it in.
942 Sometimes A comes out negative. This is significant, since
943 A has more bits than a long int does. */
944 if (a < 0)
945 v -= (UWtype) (- a);
946 else
947 v += (UWtype) a;
948 return v;
949 }
950 #endif
951
952 #ifdef L_fixdfdi
953 DWtype
954 __fixdfdi (DFtype a)
955 {
956 if (a < 0)
957 return - __fixunsdfDI (-a);
958 return __fixunsdfDI (a);
959 }
960 #endif
961
962 #ifdef L_fixunssfdi
963 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
964 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
965
966 DWtype
967 __fixunssfDI (SFtype original_a)
968 {
969 /* Convert the SFtype to a DFtype, because that is surely not going
970 to lose any bits. Some day someone else can write a faster version
971 that avoids converting to DFtype, and verify it really works right. */
972 DFtype a = original_a;
973 DFtype b;
974 UDWtype v;
975
976 if (a < 0)
977 return 0;
978
979 /* Compute high word of result, as a flonum. */
980 b = (a / HIGH_WORD_COEFF);
981 /* Convert that to fixed (but not to DWtype!),
982 and shift it into the high word. */
983 v = (UWtype) b;
984 v <<= WORD_SIZE;
985 /* Remove high part from the DFtype, leaving the low part as flonum. */
986 a -= (DFtype) v;
987 /* Convert that to fixed (but not to DWtype!) and add it in.
988 Sometimes A comes out negative. This is significant, since
989 A has more bits than a long int does. */
990 if (a < 0)
991 v -= (UWtype) (- a);
992 else
993 v += (UWtype) a;
994 return v;
995 }
996 #endif
997
998 #ifdef L_fixsfdi
999 DWtype
1000 __fixsfdi (SFtype a)
1001 {
1002 if (a < 0)
1003 return - __fixunssfDI (-a);
1004 return __fixunssfDI (a);
1005 }
1006 #endif
1007
1008 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1009 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1010 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1011 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1012
1013 XFtype
1014 __floatdixf (DWtype u)
1015 {
1016 XFtype d;
1017
1018 d = (Wtype) (u >> WORD_SIZE);
1019 d *= HIGH_HALFWORD_COEFF;
1020 d *= HIGH_HALFWORD_COEFF;
1021 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1022
1023 return d;
1024 }
1025 #endif
1026
1027 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1028 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1029 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1030 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1031
1032 TFtype
1033 __floatditf (DWtype u)
1034 {
1035 TFtype d;
1036
1037 d = (Wtype) (u >> WORD_SIZE);
1038 d *= HIGH_HALFWORD_COEFF;
1039 d *= HIGH_HALFWORD_COEFF;
1040 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1041
1042 return d;
1043 }
1044 #endif
1045
1046 #ifdef L_floatdidf
1047 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1048 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1049 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1050
1051 DFtype
1052 __floatdidf (DWtype u)
1053 {
1054 DFtype d;
1055
1056 d = (Wtype) (u >> WORD_SIZE);
1057 d *= HIGH_HALFWORD_COEFF;
1058 d *= HIGH_HALFWORD_COEFF;
1059 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1060
1061 return d;
1062 }
1063 #endif
1064
1065 #ifdef L_floatdisf
1066 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1067 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1068 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1069 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1070
1071 /* Define codes for all the float formats that we know of. Note
1072 that this is copied from real.h. */
1073
1074 #define UNKNOWN_FLOAT_FORMAT 0
1075 #define IEEE_FLOAT_FORMAT 1
1076 #define VAX_FLOAT_FORMAT 2
1077 #define IBM_FLOAT_FORMAT 3
1078
1079 /* Default to IEEE float if not specified. Nearly all machines use it. */
1080 #ifndef HOST_FLOAT_FORMAT
1081 #define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT
1082 #endif
1083
1084 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1085 #define DF_SIZE 53
1086 #define SF_SIZE 24
1087 #endif
1088
1089 #if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
1090 #define DF_SIZE 56
1091 #define SF_SIZE 24
1092 #endif
1093
1094 #if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
1095 #define DF_SIZE 56
1096 #define SF_SIZE 24
1097 #endif
1098
1099 SFtype
1100 __floatdisf (DWtype u)
1101 {
1102 /* Do the calculation in DFmode
1103 so that we don't lose any of the precision of the high word
1104 while multiplying it. */
1105 DFtype f;
1106
1107 /* Protect against double-rounding error.
1108 Represent any low-order bits, that might be truncated in DFmode,
1109 by a bit that won't be lost. The bit can go in anywhere below the
1110 rounding position of the SFmode. A fixed mask and bit position
1111 handles all usual configurations. It doesn't handle the case
1112 of 128-bit DImode, however. */
1113 if (DF_SIZE < DI_SIZE
1114 && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1115 {
1116 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1117 if (! (- ((DWtype) 1 << DF_SIZE) < u
1118 && u < ((DWtype) 1 << DF_SIZE)))
1119 {
1120 if ((UDWtype) u & (REP_BIT - 1))
1121 u |= REP_BIT;
1122 }
1123 }
1124 f = (Wtype) (u >> WORD_SIZE);
1125 f *= HIGH_HALFWORD_COEFF;
1126 f *= HIGH_HALFWORD_COEFF;
1127 f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1128
1129 return (SFtype) f;
1130 }
1131 #endif
1132
1133 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1134 /* Reenable the normal types, in case limits.h needs them. */
1135 #undef char
1136 #undef short
1137 #undef int
1138 #undef long
1139 #undef unsigned
1140 #undef float
1141 #undef double
1142 #undef MIN
1143 #undef MAX
1144 #include <limits.h>
1145
1146 UWtype
1147 __fixunsxfSI (XFtype a)
1148 {
1149 if (a >= - (DFtype) LONG_MIN)
1150 return (Wtype) (a + LONG_MIN) - LONG_MIN;
1151 return (Wtype) a;
1152 }
1153 #endif
1154
1155 #ifdef L_fixunsdfsi
1156 /* Reenable the normal types, in case limits.h needs them. */
1157 #undef char
1158 #undef short
1159 #undef int
1160 #undef long
1161 #undef unsigned
1162 #undef float
1163 #undef double
1164 #undef MIN
1165 #undef MAX
1166 #include <limits.h>
1167
1168 UWtype
1169 __fixunsdfSI (DFtype a)
1170 {
1171 if (a >= - (DFtype) LONG_MIN)
1172 return (Wtype) (a + LONG_MIN) - LONG_MIN;
1173 return (Wtype) a;
1174 }
1175 #endif
1176
1177 #ifdef L_fixunssfsi
1178 /* Reenable the normal types, in case limits.h needs them. */
1179 #undef char
1180 #undef short
1181 #undef int
1182 #undef long
1183 #undef unsigned
1184 #undef float
1185 #undef double
1186 #undef MIN
1187 #undef MAX
1188 #include <limits.h>
1189
1190 UWtype
1191 __fixunssfSI (SFtype a)
1192 {
1193 if (a >= - (SFtype) LONG_MIN)
1194 return (Wtype) (a + LONG_MIN) - LONG_MIN;
1195 return (Wtype) a;
1196 }
1197 #endif
1198 \f
1199 /* From here on down, the routines use normal data types. */
1200
1201 #define SItype bogus_type
1202 #define USItype bogus_type
1203 #define DItype bogus_type
1204 #define UDItype bogus_type
1205 #define SFtype bogus_type
1206 #define DFtype bogus_type
1207 #undef Wtype
1208 #undef UWtype
1209 #undef HWtype
1210 #undef UHWtype
1211 #undef DWtype
1212 #undef UDWtype
1213
1214 #undef char
1215 #undef short
1216 #undef int
1217 #undef long
1218 #undef unsigned
1219 #undef float
1220 #undef double
1221 \f
1222 #ifdef L__gcc_bcmp
1223
1224 /* Like bcmp except the sign is meaningful.
1225 Result is negative if S1 is less than S2,
1226 positive if S1 is greater, 0 if S1 and S2 are equal. */
1227
1228 int
1229 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1230 {
1231 while (size > 0)
1232 {
1233 unsigned char c1 = *s1++, c2 = *s2++;
1234 if (c1 != c2)
1235 return c1 - c2;
1236 size--;
1237 }
1238 return 0;
1239 }
1240
1241 #endif
1242 \f\f
1243 #ifdef L__dummy
1244 void
1245 __dummy (void) {}
1246 #endif
1247
1248 #ifdef L_varargs
1249 #ifdef __i860__
1250 #if defined(__svr4__) || defined(__alliant__)
1251 asm (" .text");
1252 asm (" .align 4");
1253
1254 /* The Alliant needs the added underscore. */
1255 asm (".globl __builtin_saveregs");
1256 asm ("__builtin_saveregs:");
1257 asm (".globl ___builtin_saveregs");
1258 asm ("___builtin_saveregs:");
1259
1260 asm (" andnot 0x0f,%sp,%sp"); /* round down to 16-byte boundary */
1261 asm (" adds -96,%sp,%sp"); /* allocate stack space for reg save
1262 area and also for a new va_list
1263 structure */
1264 /* Save all argument registers in the arg reg save area. The
1265 arg reg save area must have the following layout (according
1266 to the svr4 ABI):
1267
1268 struct {
1269 union {
1270 float freg[8];
1271 double dreg[4];
1272 } float_regs;
1273 long ireg[12];
1274 };
1275 */
1276
1277 asm (" fst.q %f8, 0(%sp)"); /* save floating regs (f8-f15) */
1278 asm (" fst.q %f12,16(%sp)");
1279
1280 asm (" st.l %r16,32(%sp)"); /* save integer regs (r16-r27) */
1281 asm (" st.l %r17,36(%sp)");
1282 asm (" st.l %r18,40(%sp)");
1283 asm (" st.l %r19,44(%sp)");
1284 asm (" st.l %r20,48(%sp)");
1285 asm (" st.l %r21,52(%sp)");
1286 asm (" st.l %r22,56(%sp)");
1287 asm (" st.l %r23,60(%sp)");
1288 asm (" st.l %r24,64(%sp)");
1289 asm (" st.l %r25,68(%sp)");
1290 asm (" st.l %r26,72(%sp)");
1291 asm (" st.l %r27,76(%sp)");
1292
1293 asm (" adds 80,%sp,%r16"); /* compute the address of the new
1294 va_list structure. Put in into
1295 r16 so that it will be returned
1296 to the caller. */
1297
1298 /* Initialize all fields of the new va_list structure. This
1299 structure looks like:
1300
1301 typedef struct {
1302 unsigned long ireg_used;
1303 unsigned long freg_used;
1304 long *reg_base;
1305 long *mem_ptr;
1306 } va_list;
1307 */
1308
1309 asm (" st.l %r0, 0(%r16)"); /* nfixed */
1310 asm (" st.l %r0, 4(%r16)"); /* nfloating */
1311 asm (" st.l %sp, 8(%r16)"); /* __va_ctl points to __va_struct. */
1312 asm (" bri %r1"); /* delayed return */
1313 asm (" st.l %r28,12(%r16)"); /* pointer to overflow args */
1314
1315 #else /* not __svr4__ */
1316 #if defined(__PARAGON__)
1317 /*
1318 * we'll use SVR4-ish varargs but need SVR3.2 assembler syntax,
1319 * and we stand a better chance of hooking into libraries
1320 * compiled by PGI. [andyp@ssd.intel.com]
1321 */
1322 asm (" .text");
1323 asm (" .align 4");
1324 asm (".globl __builtin_saveregs");
1325 asm ("__builtin_saveregs:");
1326 asm (".globl ___builtin_saveregs");
1327 asm ("___builtin_saveregs:");
1328
1329 asm (" andnot 0x0f,sp,sp"); /* round down to 16-byte boundary */
1330 asm (" adds -96,sp,sp"); /* allocate stack space for reg save
1331 area and also for a new va_list
1332 structure */
1333 /* Save all argument registers in the arg reg save area. The
1334 arg reg save area must have the following layout (according
1335 to the svr4 ABI):
1336
1337 struct {
1338 union {
1339 float freg[8];
1340 double dreg[4];
1341 } float_regs;
1342 long ireg[12];
1343 };
1344 */
1345
1346 asm (" fst.q f8, 0(sp)");
1347 asm (" fst.q f12,16(sp)");
1348 asm (" st.l r16,32(sp)");
1349 asm (" st.l r17,36(sp)");
1350 asm (" st.l r18,40(sp)");
1351 asm (" st.l r19,44(sp)");
1352 asm (" st.l r20,48(sp)");
1353 asm (" st.l r21,52(sp)");
1354 asm (" st.l r22,56(sp)");
1355 asm (" st.l r23,60(sp)");
1356 asm (" st.l r24,64(sp)");
1357 asm (" st.l r25,68(sp)");
1358 asm (" st.l r26,72(sp)");
1359 asm (" st.l r27,76(sp)");
1360
1361 asm (" adds 80,sp,r16"); /* compute the address of the new
1362 va_list structure. Put in into
1363 r16 so that it will be returned
1364 to the caller. */
1365
1366 /* Initialize all fields of the new va_list structure. This
1367 structure looks like:
1368
1369 typedef struct {
1370 unsigned long ireg_used;
1371 unsigned long freg_used;
1372 long *reg_base;
1373 long *mem_ptr;
1374 } va_list;
1375 */
1376
1377 asm (" st.l r0, 0(r16)"); /* nfixed */
1378 asm (" st.l r0, 4(r16)"); /* nfloating */
1379 asm (" st.l sp, 8(r16)"); /* __va_ctl points to __va_struct. */
1380 asm (" bri r1"); /* delayed return */
1381 asm (" st.l r28,12(r16)"); /* pointer to overflow args */
1382 #else /* not __PARAGON__ */
1383 asm (" .text");
1384 asm (" .align 4");
1385
1386 asm (".globl ___builtin_saveregs");
1387 asm ("___builtin_saveregs:");
1388 asm (" mov sp,r30");
1389 asm (" andnot 0x0f,sp,sp");
1390 asm (" adds -96,sp,sp"); /* allocate sufficient space on the stack */
1391
1392 /* Fill in the __va_struct. */
1393 asm (" st.l r16, 0(sp)"); /* save integer regs (r16-r27) */
1394 asm (" st.l r17, 4(sp)"); /* int fixed[12] */
1395 asm (" st.l r18, 8(sp)");
1396 asm (" st.l r19,12(sp)");
1397 asm (" st.l r20,16(sp)");
1398 asm (" st.l r21,20(sp)");
1399 asm (" st.l r22,24(sp)");
1400 asm (" st.l r23,28(sp)");
1401 asm (" st.l r24,32(sp)");
1402 asm (" st.l r25,36(sp)");
1403 asm (" st.l r26,40(sp)");
1404 asm (" st.l r27,44(sp)");
1405
1406 asm (" fst.q f8, 48(sp)"); /* save floating regs (f8-f15) */
1407 asm (" fst.q f12,64(sp)"); /* int floating[8] */
1408
1409 /* Fill in the __va_ctl. */
1410 asm (" st.l sp, 80(sp)"); /* __va_ctl points to __va_struct. */
1411 asm (" st.l r28,84(sp)"); /* pointer to more args */
1412 asm (" st.l r0, 88(sp)"); /* nfixed */
1413 asm (" st.l r0, 92(sp)"); /* nfloating */
1414
1415 asm (" adds 80,sp,r16"); /* return address of the __va_ctl. */
1416 asm (" bri r1");
1417 asm (" mov r30,sp");
1418 /* recover stack and pass address to start
1419 of data. */
1420 #endif /* not __PARAGON__ */
1421 #endif /* not __svr4__ */
1422 #else /* not __i860__ */
1423 #ifdef __sparc__
1424 asm (".global __builtin_saveregs");
1425 asm ("__builtin_saveregs:");
1426 asm (".global ___builtin_saveregs");
1427 asm ("___builtin_saveregs:");
1428 #ifdef NEED_PROC_COMMAND
1429 asm (".proc 020");
1430 #endif
1431 asm ("st %i0,[%fp+68]");
1432 asm ("st %i1,[%fp+72]");
1433 asm ("st %i2,[%fp+76]");
1434 asm ("st %i3,[%fp+80]");
1435 asm ("st %i4,[%fp+84]");
1436 asm ("retl");
1437 asm ("st %i5,[%fp+88]");
1438 #ifdef NEED_TYPE_COMMAND
1439 asm (".type __builtin_saveregs,#function");
1440 asm (".size __builtin_saveregs,.-__builtin_saveregs");
1441 #endif
1442 #else /* not __sparc__ */
1443 #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
1444
1445 asm (" .text");
1446 #ifdef __mips16
1447 asm (" .set nomips16");
1448 #endif
1449 asm (" .ent __builtin_saveregs");
1450 asm (" .globl __builtin_saveregs");
1451 asm ("__builtin_saveregs:");
1452 asm (" sw $4,0($30)");
1453 asm (" sw $5,4($30)");
1454 asm (" sw $6,8($30)");
1455 asm (" sw $7,12($30)");
1456 asm (" j $31");
1457 asm (" .end __builtin_saveregs");
1458 #else /* not __mips__, etc. */
1459
1460 void * __attribute__ ((__noreturn__))
1461 __builtin_saveregs (void)
1462 {
1463 abort ();
1464 }
1465
1466 #endif /* not __mips__ */
1467 #endif /* not __sparc__ */
1468 #endif /* not __i860__ */
1469 #endif
1470 \f
1471 #ifdef L_eprintf
1472 #ifndef inhibit_libc
1473
1474 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1475 #include <stdio.h>
1476 /* This is used by the `assert' macro. */
1477 void
1478 __eprintf (const char *string, const char *expression,
1479 unsigned int line, const char *filename)
1480 {
1481 fprintf (stderr, string, expression, line, filename);
1482 fflush (stderr);
1483 abort ();
1484 }
1485
1486 #endif
1487 #endif
1488
1489 #ifdef L_bb
1490
1491 /* Structure emitted by -a */
1492 struct bb
1493 {
1494 long zero_word;
1495 const char *filename;
1496 long *counts;
1497 long ncounts;
1498 struct bb *next;
1499 const unsigned long *addresses;
1500
1501 /* Older GCC's did not emit these fields. */
1502 long nwords;
1503 const char **functions;
1504 const long *line_nums;
1505 const char **filenames;
1506 char *flags;
1507 };
1508
1509 #ifdef BLOCK_PROFILER_CODE
1510 BLOCK_PROFILER_CODE
1511 #else
1512 #ifndef inhibit_libc
1513
1514 /* Simple minded basic block profiling output dumper for
1515 systems that don't provide tcov support. At present,
1516 it requires atexit and stdio. */
1517
1518 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1519 #include <stdio.h>
1520 char *ctime ();
1521
1522 #include "gbl-ctors.h"
1523 #include "gcov-io.h"
1524 #include <string.h>
1525 #ifdef TARGET_HAS_F_SETLKW
1526 #include <fcntl.h>
1527 #include <errno.h>
1528 #endif
1529
1530 static struct bb *bb_head;
1531
1532 static int num_digits (long value, int base) __attribute__ ((const));
1533
1534 /* Return the number of digits needed to print a value */
1535 /* __inline__ */ static int num_digits (long value, int base)
1536 {
1537 int minus = (value < 0 && base != 16);
1538 unsigned long v = (minus) ? -value : value;
1539 int ret = minus;
1540
1541 do
1542 {
1543 v /= base;
1544 ret++;
1545 }
1546 while (v);
1547
1548 return ret;
1549 }
1550
1551 void
1552 __bb_exit_func (void)
1553 {
1554 FILE *da_file, *file;
1555 long time_value;
1556 int i;
1557
1558 if (bb_head == 0)
1559 return;
1560
1561 i = strlen (bb_head->filename) - 3;
1562
1563 if (!strcmp (bb_head->filename+i, ".da"))
1564 {
1565 /* Must be -fprofile-arcs not -a.
1566 Dump data in a form that gcov expects. */
1567
1568 struct bb *ptr;
1569
1570 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1571 {
1572 int firstchar;
1573
1574 /* Make sure the output file exists -
1575 but don't clobber exiting data. */
1576 if ((da_file = fopen (ptr->filename, "a")) != 0)
1577 fclose (da_file);
1578
1579 /* Need to re-open in order to be able to write from the start. */
1580 da_file = fopen (ptr->filename, "r+b");
1581 /* Some old systems might not allow the 'b' mode modifier.
1582 Therefore, try to open without it. This can lead to a race
1583 condition so that when you delete and re-create the file, the
1584 file might be opened in text mode, but then, you shouldn't
1585 delete the file in the first place. */
1586 if (da_file == 0)
1587 da_file = fopen (ptr->filename, "r+");
1588 if (da_file == 0)
1589 {
1590 fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1591 ptr->filename);
1592 continue;
1593 }
1594
1595 /* After a fork, another process might try to read and/or write
1596 the same file simultanously. So if we can, lock the file to
1597 avoid race conditions. */
1598 #if defined (TARGET_HAS_F_SETLKW)
1599 {
1600 struct flock s_flock;
1601
1602 s_flock.l_type = F_WRLCK;
1603 s_flock.l_whence = SEEK_SET;
1604 s_flock.l_start = 0;
1605 s_flock.l_len = 1;
1606 s_flock.l_pid = getpid ();
1607
1608 while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1609 && errno == EINTR);
1610 }
1611 #endif
1612
1613 /* If the file is not empty, and the number of counts in it is the
1614 same, then merge them in. */
1615 firstchar = fgetc (da_file);
1616 if (firstchar == EOF)
1617 {
1618 if (ferror (da_file))
1619 {
1620 fprintf (stderr, "arc profiling: Can't read output file ");
1621 perror (ptr->filename);
1622 }
1623 }
1624 else
1625 {
1626 long n_counts = 0;
1627
1628 if (ungetc (firstchar, da_file) == EOF)
1629 rewind (da_file);
1630 if (__read_long (&n_counts, da_file, 8) != 0)
1631 {
1632 fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1633 ptr->filename);
1634 continue;
1635 }
1636
1637 if (n_counts == ptr->ncounts)
1638 {
1639 int i;
1640
1641 for (i = 0; i < n_counts; i++)
1642 {
1643 long v = 0;
1644
1645 if (__read_long (&v, da_file, 8) != 0)
1646 {
1647 fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1648 ptr->filename);
1649 break;
1650 }
1651 ptr->counts[i] += v;
1652 }
1653 }
1654
1655 }
1656
1657 rewind (da_file);
1658
1659 /* ??? Should first write a header to the file. Preferably, a 4 byte
1660 magic number, 4 bytes containing the time the program was
1661 compiled, 4 bytes containing the last modification time of the
1662 source file, and 4 bytes indicating the compiler options used.
1663
1664 That way we can easily verify that the proper source/executable/
1665 data file combination is being used from gcov. */
1666
1667 if (__write_long (ptr->ncounts, da_file, 8) != 0)
1668 {
1669
1670 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1671 ptr->filename);
1672 }
1673 else
1674 {
1675 int j;
1676 long *count_ptr = ptr->counts;
1677 int ret = 0;
1678 for (j = ptr->ncounts; j > 0; j--)
1679 {
1680 if (__write_long (*count_ptr, da_file, 8) != 0)
1681 {
1682 ret=1;
1683 break;
1684 }
1685 count_ptr++;
1686 }
1687 if (ret)
1688 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1689 ptr->filename);
1690 }
1691
1692 if (fclose (da_file) == EOF)
1693 fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1694 ptr->filename);
1695 }
1696
1697 return;
1698 }
1699
1700 /* Must be basic block profiling. Emit a human readable output file. */
1701
1702 file = fopen ("bb.out", "a");
1703
1704 if (!file)
1705 perror ("bb.out");
1706
1707 else
1708 {
1709 struct bb *ptr;
1710
1711 /* This is somewhat type incorrect, but it avoids worrying about
1712 exactly where time.h is included from. It should be ok unless
1713 a void * differs from other pointer formats, or if sizeof (long)
1714 is < sizeof (time_t). It would be nice if we could assume the
1715 use of rationale standards here. */
1716
1717 time ((void *) &time_value);
1718 fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
1719
1720 /* We check the length field explicitly in order to allow compatibility
1721 with older GCC's which did not provide it. */
1722
1723 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1724 {
1725 int i;
1726 int func_p = (ptr->nwords >= (long) sizeof (struct bb)
1727 && ptr->nwords <= 1000
1728 && ptr->functions);
1729 int line_p = (func_p && ptr->line_nums);
1730 int file_p = (func_p && ptr->filenames);
1731 int addr_p = (ptr->addresses != 0);
1732 long ncounts = ptr->ncounts;
1733 long cnt_max = 0;
1734 long line_max = 0;
1735 long addr_max = 0;
1736 int file_len = 0;
1737 int func_len = 0;
1738 int blk_len = num_digits (ncounts, 10);
1739 int cnt_len;
1740 int line_len;
1741 int addr_len;
1742
1743 fprintf (file, "File %s, %ld basic blocks \n\n",
1744 ptr->filename, ncounts);
1745
1746 /* Get max values for each field. */
1747 for (i = 0; i < ncounts; i++)
1748 {
1749 const char *p;
1750 int len;
1751
1752 if (cnt_max < ptr->counts[i])
1753 cnt_max = ptr->counts[i];
1754
1755 if (addr_p && (unsigned long) addr_max < ptr->addresses[i])
1756 addr_max = ptr->addresses[i];
1757
1758 if (line_p && line_max < ptr->line_nums[i])
1759 line_max = ptr->line_nums[i];
1760
1761 if (func_p)
1762 {
1763 p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
1764 len = strlen (p);
1765 if (func_len < len)
1766 func_len = len;
1767 }
1768
1769 if (file_p)
1770 {
1771 p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
1772 len = strlen (p);
1773 if (file_len < len)
1774 file_len = len;
1775 }
1776 }
1777
1778 addr_len = num_digits (addr_max, 16);
1779 cnt_len = num_digits (cnt_max, 10);
1780 line_len = num_digits (line_max, 10);
1781
1782 /* Now print out the basic block information. */
1783 for (i = 0; i < ncounts; i++)
1784 {
1785 fprintf (file,
1786 " Block #%*d: executed %*ld time(s)",
1787 blk_len, i+1,
1788 cnt_len, ptr->counts[i]);
1789
1790 if (addr_p)
1791 fprintf (file, " address= 0x%.*lx", addr_len,
1792 ptr->addresses[i]);
1793
1794 if (func_p)
1795 fprintf (file, " function= %-*s", func_len,
1796 (ptr->functions[i]) ? ptr->functions[i] : "<none>");
1797
1798 if (line_p)
1799 fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
1800
1801 if (file_p)
1802 fprintf (file, " file= %s",
1803 (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
1804
1805 fprintf (file, "\n");
1806 }
1807
1808 fprintf (file, "\n");
1809 fflush (file);
1810 }
1811
1812 fprintf (file, "\n\n");
1813 fclose (file);
1814 }
1815 }
1816
1817 void
1818 __bb_init_func (struct bb *blocks)
1819 {
1820 /* User is supposed to check whether the first word is non-0,
1821 but just in case.... */
1822
1823 if (blocks->zero_word)
1824 return;
1825
1826 /* Initialize destructor. */
1827 if (!bb_head)
1828 atexit (__bb_exit_func);
1829
1830 /* Set up linked list. */
1831 blocks->zero_word = 1;
1832 blocks->next = bb_head;
1833 bb_head = blocks;
1834 }
1835
1836 /* Called before fork or exec - write out profile information gathered so
1837 far and reset it to zero. This avoids duplication or loss of the
1838 profile information gathered so far. */
1839 void
1840 __bb_fork_func (void)
1841 {
1842 struct bb *ptr;
1843
1844 __bb_exit_func ();
1845 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1846 {
1847 long i;
1848 for (i = ptr->ncounts - 1; i >= 0; i--)
1849 ptr->counts[i] = 0;
1850 }
1851 }
1852
1853 #ifndef MACHINE_STATE_SAVE
1854 #define MACHINE_STATE_SAVE(ID)
1855 #endif
1856 #ifndef MACHINE_STATE_RESTORE
1857 #define MACHINE_STATE_RESTORE(ID)
1858 #endif
1859
1860 /* Number of buckets in hashtable of basic block addresses. */
1861
1862 #define BB_BUCKETS 311
1863
1864 /* Maximum length of string in file bb.in. */
1865
1866 #define BBINBUFSIZE 500
1867
1868 struct bb_edge
1869 {
1870 struct bb_edge *next;
1871 unsigned long src_addr;
1872 unsigned long dst_addr;
1873 unsigned long count;
1874 };
1875
1876 enum bb_func_mode
1877 {
1878 TRACE_KEEP = 0, TRACE_ON = 1, TRACE_OFF = 2
1879 };
1880
1881 struct bb_func
1882 {
1883 struct bb_func *next;
1884 char *funcname;
1885 char *filename;
1886 enum bb_func_mode mode;
1887 };
1888
1889 /* This is the connection to the outside world.
1890 The BLOCK_PROFILER macro must set __bb.blocks
1891 and __bb.blockno. */
1892
1893 struct {
1894 unsigned long blockno;
1895 struct bb *blocks;
1896 } __bb;
1897
1898 /* Vars to store addrs of source and destination basic blocks
1899 of a jump. */
1900
1901 static unsigned long bb_src = 0;
1902 static unsigned long bb_dst = 0;
1903
1904 static FILE *bb_tracefile = (FILE *) 0;
1905 static struct bb_edge **bb_hashbuckets = (struct bb_edge **) 0;
1906 static struct bb_func *bb_func_head = (struct bb_func *) 0;
1907 static unsigned long bb_callcount = 0;
1908 static int bb_mode = 0;
1909
1910 static unsigned long *bb_stack = (unsigned long *) 0;
1911 static size_t bb_stacksize = 0;
1912
1913 static int reported = 0;
1914
1915 /* Trace modes:
1916 Always : Print execution frequencies of basic blocks
1917 to file bb.out.
1918 bb_mode & 1 != 0 : Dump trace of basic blocks to file bbtrace[.gz]
1919 bb_mode & 2 != 0 : Print jump frequencies to file bb.out.
1920 bb_mode & 4 != 0 : Cut call instructions from basic block flow.
1921 bb_mode & 8 != 0 : Insert return instructions in basic block flow.
1922 */
1923
1924 #ifdef HAVE_POPEN
1925
1926 /*#include <sys/types.h>*/
1927 #include <sys/stat.h>
1928 /*#include <malloc.h>*/
1929
1930 /* Commands executed by gopen. */
1931
1932 #define GOPENDECOMPRESS "gzip -cd "
1933 #define GOPENCOMPRESS "gzip -c >"
1934
1935 /* Like fopen but pipes through gzip. mode may only be "r" or "w".
1936 If it does not compile, simply replace gopen by fopen and delete
1937 '.gz' from any first parameter to gopen. */
1938
1939 static FILE *
1940 gopen (char *fn, char *mode)
1941 {
1942 int use_gzip;
1943 char *p;
1944
1945 if (mode[1])
1946 return (FILE *) 0;
1947
1948 if (mode[0] != 'r' && mode[0] != 'w')
1949 return (FILE *) 0;
1950
1951 p = fn + strlen (fn)-1;
1952 use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z'))
1953 || (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));
1954
1955 if (use_gzip)
1956 {
1957 if (mode[0]=='r')
1958 {
1959 FILE *f;
1960 char *s = (char *) malloc (sizeof (char) * strlen (fn)
1961 + sizeof (GOPENDECOMPRESS));
1962 strcpy (s, GOPENDECOMPRESS);
1963 strcpy (s + (sizeof (GOPENDECOMPRESS)-1), fn);
1964 f = popen (s, mode);
1965 free (s);
1966 return f;
1967 }
1968
1969 else
1970 {
1971 FILE *f;
1972 char *s = (char *) malloc (sizeof (char) * strlen (fn)
1973 + sizeof (GOPENCOMPRESS));
1974 strcpy (s, GOPENCOMPRESS);
1975 strcpy (s + (sizeof (GOPENCOMPRESS)-1), fn);
1976 if (!(f = popen (s, mode)))
1977 f = fopen (s, mode);
1978 free (s);
1979 return f;
1980 }
1981 }
1982
1983 else
1984 return fopen (fn, mode);
1985 }
1986
1987 static int
1988 gclose (FILE *f)
1989 {
1990 struct stat buf;
1991
1992 if (f != 0)
1993 {
1994 if (!fstat (fileno (f), &buf) && S_ISFIFO (buf.st_mode))
1995 return pclose (f);
1996
1997 return fclose (f);
1998 }
1999 return 0;
2000 }
2001
2002 #endif /* HAVE_POPEN */
2003
2004 /* Called once per program. */
2005
2006 static void
2007 __bb_exit_trace_func (void)
2008 {
2009 FILE *file = fopen ("bb.out", "a");
2010 struct bb_func *f;
2011 struct bb *b;
2012
2013 if (!file)
2014 perror ("bb.out");
2015
2016 if (bb_mode & 1)
2017 {
2018 if (!bb_tracefile)
2019 perror ("bbtrace");
2020 else
2021 #ifdef HAVE_POPEN
2022 gclose (bb_tracefile);
2023 #else
2024 fclose (bb_tracefile);
2025 #endif /* HAVE_POPEN */
2026 }
2027
2028 /* Check functions in `bb.in'. */
2029
2030 if (file)
2031 {
2032 long time_value;
2033 const struct bb_func *p;
2034 int printed_something = 0;
2035 struct bb *ptr;
2036 long blk;
2037
2038 /* This is somewhat type incorrect. */
2039 time ((void *) &time_value);
2040
2041 for (p = bb_func_head; p != (struct bb_func *) 0; p = p->next)
2042 {
2043 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
2044 {
2045 if (!ptr->filename || (p->filename != (char *) 0 && strcmp (p->filename, ptr->filename)))
2046 continue;
2047 for (blk = 0; blk < ptr->ncounts; blk++)
2048 {
2049 if (!strcmp (p->funcname, ptr->functions[blk]))
2050 goto found;
2051 }
2052 }
2053
2054 if (!printed_something)
2055 {
2056 fprintf (file, "Functions in `bb.in' not executed during basic block profiling on %s\n", ctime ((void *) &time_value));
2057 printed_something = 1;
2058 }
2059
2060 fprintf (file, "\tFunction %s", p->funcname);
2061 if (p->filename)
2062 fprintf (file, " of file %s", p->filename);
2063 fprintf (file, "\n" );
2064
2065 found: ;
2066 }
2067
2068 if (printed_something)
2069 fprintf (file, "\n");
2070
2071 }
2072
2073 if (bb_mode & 2)
2074 {
2075 if (!bb_hashbuckets)
2076 {
2077 if (!reported)
2078 {
2079 fprintf (stderr, "Profiler: out of memory\n");
2080 reported = 1;
2081 }
2082 return;
2083 }
2084
2085 else if (file)
2086 {
2087 long time_value;
2088 int i;
2089 unsigned long addr_max = 0;
2090 unsigned long cnt_max = 0;
2091 int cnt_len;
2092 int addr_len;
2093
2094 /* This is somewhat type incorrect, but it avoids worrying about
2095 exactly where time.h is included from. It should be ok unless
2096 a void * differs from other pointer formats, or if sizeof (long)
2097 is < sizeof (time_t). It would be nice if we could assume the
2098 use of rationale standards here. */
2099
2100 time ((void *) &time_value);
2101 fprintf (file, "Basic block jump tracing");
2102
2103 switch (bb_mode & 12)
2104 {
2105 case 0:
2106 fprintf (file, " (with call)");
2107 break;
2108
2109 case 4:
2110 /* Print nothing. */
2111 break;
2112
2113 case 8:
2114 fprintf (file, " (with call & ret)");
2115 break;
2116
2117 case 12:
2118 fprintf (file, " (with ret)");
2119 break;
2120 }
2121
2122 fprintf (file, " finished on %s\n", ctime ((void *) &time_value));
2123
2124 for (i = 0; i < BB_BUCKETS; i++)
2125 {
2126 struct bb_edge *bucket = bb_hashbuckets[i];
2127 for ( ; bucket; bucket = bucket->next )
2128 {
2129 if (addr_max < bucket->src_addr)
2130 addr_max = bucket->src_addr;
2131 if (addr_max < bucket->dst_addr)
2132 addr_max = bucket->dst_addr;
2133 if (cnt_max < bucket->count)
2134 cnt_max = bucket->count;
2135 }
2136 }
2137 addr_len = num_digits (addr_max, 16);
2138 cnt_len = num_digits (cnt_max, 10);
2139
2140 for ( i = 0; i < BB_BUCKETS; i++)
2141 {
2142 struct bb_edge *bucket = bb_hashbuckets[i];
2143 for ( ; bucket; bucket = bucket->next )
2144 {
2145 fprintf (file,
2146 "Jump from block 0x%.*lx to block 0x%.*lx executed %*lu time(s)\n",
2147 addr_len, bucket->src_addr,
2148 addr_len, bucket->dst_addr,
2149 cnt_len, bucket->count);
2150 }
2151 }
2152
2153 fprintf (file, "\n");
2154
2155 }
2156 }
2157
2158 if (file)
2159 fclose (file);
2160
2161 /* Free allocated memory. */
2162
2163 f = bb_func_head;
2164 while (f)
2165 {
2166 struct bb_func *old = f;
2167
2168 f = f->next;
2169 if (old->funcname) free (old->funcname);
2170 if (old->filename) free (old->filename);
2171 free (old);
2172 }
2173
2174 if (bb_stack)
2175 free (bb_stack);
2176
2177 if (bb_hashbuckets)
2178 {
2179 int i;
2180
2181 for (i = 0; i < BB_BUCKETS; i++)
2182 {
2183 struct bb_edge *old, *bucket = bb_hashbuckets[i];
2184
2185 while (bucket)
2186 {
2187 old = bucket;
2188 bucket = bucket->next;
2189 free (old);
2190 }
2191 }
2192 free (bb_hashbuckets);
2193 }
2194
2195 for (b = bb_head; b; b = b->next)
2196 if (b->flags) free (b->flags);
2197 }
2198
2199 /* Called once per program. */
2200
2201 static void
2202 __bb_init_prg (void)
2203 {
2204 FILE *file;
2205 char buf[BBINBUFSIZE];
2206 const char *p;
2207 const char *pos;
2208 enum bb_func_mode m;
2209 int i;
2210
2211 /* Initialize destructor. */
2212 atexit (__bb_exit_func);
2213
2214 if (!(file = fopen ("bb.in", "r")))
2215 return;
2216
2217 while(fgets (buf, BBINBUFSIZE, file) != 0)
2218 {
2219 i = strlen (buf);
2220 if (buf[i] == '\n')
2221 buf[i--] = '\0';
2222
2223 p = buf;
2224 if (*p == '-')
2225 {
2226 m = TRACE_OFF;
2227 p++;
2228 }
2229 else
2230 {
2231 m = TRACE_ON;
2232 }
2233 if (!strcmp (p, "__bb_trace__"))
2234 bb_mode |= 1;
2235 else if (!strcmp (p, "__bb_jumps__"))
2236 bb_mode |= 2;
2237 else if (!strcmp (p, "__bb_hidecall__"))
2238 bb_mode |= 4;
2239 else if (!strcmp (p, "__bb_showret__"))
2240 bb_mode |= 8;
2241 else
2242 {
2243 struct bb_func *f = (struct bb_func *) malloc (sizeof (struct bb_func));
2244 if (f)
2245 {
2246 unsigned long l;
2247 f->next = bb_func_head;
2248 if ((pos = strchr (p, ':')))
2249 {
2250 if (!(f->funcname = (char *) malloc (strlen (pos+1)+1)))
2251 continue;
2252 strcpy (f->funcname, pos+1);
2253 l = pos-p;
2254 if ((f->filename = (char *) malloc (l+1)))
2255 {
2256 strncpy (f->filename, p, l);
2257 f->filename[l] = '\0';
2258 }
2259 else
2260 f->filename = (char *) 0;
2261 }
2262 else
2263 {
2264 if (!(f->funcname = (char *) malloc (strlen (p)+1)))
2265 continue;
2266 strcpy (f->funcname, p);
2267 f->filename = (char *) 0;
2268 }
2269 f->mode = m;
2270 bb_func_head = f;
2271 }
2272 }
2273 }
2274 fclose (file);
2275
2276 #ifdef HAVE_POPEN
2277
2278 if (bb_mode & 1)
2279 bb_tracefile = gopen ("bbtrace.gz", "w");
2280
2281 #else
2282
2283 if (bb_mode & 1)
2284 bb_tracefile = fopen ("bbtrace", "w");
2285
2286 #endif /* HAVE_POPEN */
2287
2288 if (bb_mode & 2)
2289 {
2290 bb_hashbuckets = (struct bb_edge **)
2291 malloc (BB_BUCKETS * sizeof (struct bb_edge *));
2292 if (bb_hashbuckets)
2293 /* Use a loop here rather than calling bzero to avoid having to
2294 conditionalize its existance. */
2295 for (i = 0; i < BB_BUCKETS; i++)
2296 bb_hashbuckets[i] = 0;
2297 }
2298
2299 if (bb_mode & 12)
2300 {
2301 bb_stacksize = 10;
2302 bb_stack = (unsigned long *) malloc (bb_stacksize * sizeof (*bb_stack));
2303 }
2304
2305 /* Initialize destructor. */
2306 atexit (__bb_exit_trace_func);
2307 }
2308
2309 /* Called upon entering a basic block. */
2310
2311 void
2312 __bb_trace_func (void)
2313 {
2314 struct bb_edge *bucket;
2315
2316 MACHINE_STATE_SAVE("1")
2317
2318 if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2319 goto skip;
2320
2321 bb_dst = __bb.blocks->addresses[__bb.blockno];
2322 __bb.blocks->counts[__bb.blockno]++;
2323
2324 if (bb_tracefile)
2325 {
2326 fwrite (&bb_dst, sizeof (unsigned long), 1, bb_tracefile);
2327 }
2328
2329 if (bb_hashbuckets)
2330 {
2331 struct bb_edge **startbucket, **oldnext;
2332
2333 oldnext = startbucket
2334 = & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
2335 bucket = *startbucket;
2336
2337 for (bucket = *startbucket; bucket;
2338 oldnext = &(bucket->next), bucket = *oldnext)
2339 {
2340 if (bucket->src_addr == bb_src
2341 && bucket->dst_addr == bb_dst)
2342 {
2343 bucket->count++;
2344 *oldnext = bucket->next;
2345 bucket->next = *startbucket;
2346 *startbucket = bucket;
2347 goto ret;
2348 }
2349 }
2350
2351 bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2352
2353 if (!bucket)
2354 {
2355 if (!reported)
2356 {
2357 fprintf (stderr, "Profiler: out of memory\n");
2358 reported = 1;
2359 }
2360 }
2361
2362 else
2363 {
2364 bucket->src_addr = bb_src;
2365 bucket->dst_addr = bb_dst;
2366 bucket->next = *startbucket;
2367 *startbucket = bucket;
2368 bucket->count = 1;
2369 }
2370 }
2371
2372 ret:
2373 bb_src = bb_dst;
2374
2375 skip:
2376 ;
2377
2378 MACHINE_STATE_RESTORE("1")
2379
2380 }
2381
2382 /* Called when returning from a function and `__bb_showret__' is set. */
2383
2384 static void
2385 __bb_trace_func_ret (void)
2386 {
2387 struct bb_edge *bucket;
2388
2389 if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2390 goto skip;
2391
2392 if (bb_hashbuckets)
2393 {
2394 struct bb_edge **startbucket, **oldnext;
2395
2396 oldnext = startbucket
2397 = & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
2398 bucket = *startbucket;
2399
2400 for (bucket = *startbucket; bucket;
2401 oldnext = &(bucket->next), bucket = *oldnext)
2402 {
2403 if (bucket->src_addr == bb_dst
2404 && bucket->dst_addr == bb_src)
2405 {
2406 bucket->count++;
2407 *oldnext = bucket->next;
2408 bucket->next = *startbucket;
2409 *startbucket = bucket;
2410 goto ret;
2411 }
2412 }
2413
2414 bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2415
2416 if (!bucket)
2417 {
2418 if (!reported)
2419 {
2420 fprintf (stderr, "Profiler: out of memory\n");
2421 reported = 1;
2422 }
2423 }
2424
2425 else
2426 {
2427 bucket->src_addr = bb_dst;
2428 bucket->dst_addr = bb_src;
2429 bucket->next = *startbucket;
2430 *startbucket = bucket;
2431 bucket->count = 1;
2432 }
2433 }
2434
2435 ret:
2436 bb_dst = bb_src;
2437
2438 skip:
2439 ;
2440
2441 }
2442
2443 /* Called upon entering the first function of a file. */
2444
2445 static void
2446 __bb_init_file (struct bb *blocks)
2447 {
2448
2449 const struct bb_func *p;
2450 long blk, ncounts = blocks->ncounts;
2451 const char **functions = blocks->functions;
2452
2453 /* Set up linked list. */
2454 blocks->zero_word = 1;
2455 blocks->next = bb_head;
2456 bb_head = blocks;
2457
2458 blocks->flags = 0;
2459 if (!bb_func_head
2460 || !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
2461 return;
2462
2463 for (blk = 0; blk < ncounts; blk++)
2464 blocks->flags[blk] = 0;
2465
2466 for (blk = 0; blk < ncounts; blk++)
2467 {
2468 for (p = bb_func_head; p; p = p->next)
2469 {
2470 if (!strcmp (p->funcname, functions[blk])
2471 && (!p->filename || !strcmp (p->filename, blocks->filename)))
2472 {
2473 blocks->flags[blk] |= p->mode;
2474 }
2475 }
2476 }
2477
2478 }
2479
2480 /* Called when exiting from a function. */
2481
2482 void
2483 __bb_trace_ret (void)
2484 {
2485
2486 MACHINE_STATE_SAVE("2")
2487
2488 if (bb_callcount)
2489 {
2490 if ((bb_mode & 12) && bb_stacksize > bb_callcount)
2491 {
2492 bb_src = bb_stack[bb_callcount];
2493 if (bb_mode & 8)
2494 __bb_trace_func_ret ();
2495 }
2496
2497 bb_callcount -= 1;
2498 }
2499
2500 MACHINE_STATE_RESTORE("2")
2501
2502 }
2503
2504 /* Called when entering a function. */
2505
2506 void
2507 __bb_init_trace_func (struct bb *blocks, unsigned long blockno)
2508 {
2509 static int trace_init = 0;
2510
2511 MACHINE_STATE_SAVE("3")
2512
2513 if (!blocks->zero_word)
2514 {
2515 if (!trace_init)
2516 {
2517 trace_init = 1;
2518 __bb_init_prg ();
2519 }
2520 __bb_init_file (blocks);
2521 }
2522
2523 if (bb_callcount)
2524 {
2525
2526 bb_callcount += 1;
2527
2528 if (bb_mode & 12)
2529 {
2530 if (bb_callcount >= bb_stacksize)
2531 {
2532 size_t newsize = bb_callcount + 100;
2533
2534 bb_stack = (unsigned long *) realloc (bb_stack, newsize);
2535 if (! bb_stack)
2536 {
2537 if (!reported)
2538 {
2539 fprintf (stderr, "Profiler: out of memory\n");
2540 reported = 1;
2541 }
2542 bb_stacksize = 0;
2543 goto stack_overflow;
2544 }
2545 bb_stacksize = newsize;
2546 }
2547 bb_stack[bb_callcount] = bb_src;
2548
2549 if (bb_mode & 4)
2550 bb_src = 0;
2551
2552 }
2553
2554 stack_overflow:;
2555
2556 }
2557
2558 else if (blocks->flags && (blocks->flags[blockno] & TRACE_ON))
2559 {
2560 bb_callcount = 1;
2561 bb_src = 0;
2562
2563 if (bb_stack)
2564 bb_stack[bb_callcount] = bb_src;
2565 }
2566
2567 MACHINE_STATE_RESTORE("3")
2568 }
2569
2570 #endif /* not inhibit_libc */
2571 #endif /* not BLOCK_PROFILER_CODE */
2572 #endif /* L_bb */
2573 \f
2574 #ifdef L_clear_cache
2575 /* Clear part of an instruction cache. */
2576
2577 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
2578
2579 void
2580 __clear_cache (char *beg __attribute__((__unused__)),
2581 char *end __attribute__((__unused__)))
2582 {
2583 #ifdef CLEAR_INSN_CACHE
2584 CLEAR_INSN_CACHE (beg, end);
2585 #else
2586 #ifdef INSN_CACHE_SIZE
2587 static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
2588 static int initialized;
2589 int offset;
2590 void *start_addr
2591 void *end_addr;
2592 typedef (*function_ptr) (void);
2593
2594 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
2595 /* It's cheaper to clear the whole cache.
2596 Put in a series of jump instructions so that calling the beginning
2597 of the cache will clear the whole thing. */
2598
2599 if (! initialized)
2600 {
2601 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2602 & -INSN_CACHE_LINE_WIDTH);
2603 int end_ptr = ptr + INSN_CACHE_SIZE;
2604
2605 while (ptr < end_ptr)
2606 {
2607 *(INSTRUCTION_TYPE *)ptr
2608 = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
2609 ptr += INSN_CACHE_LINE_WIDTH;
2610 }
2611 *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
2612
2613 initialized = 1;
2614 }
2615
2616 /* Call the beginning of the sequence. */
2617 (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2618 & -INSN_CACHE_LINE_WIDTH))
2619 ());
2620
2621 #else /* Cache is large. */
2622
2623 if (! initialized)
2624 {
2625 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2626 & -INSN_CACHE_LINE_WIDTH);
2627
2628 while (ptr < (int) array + sizeof array)
2629 {
2630 *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
2631 ptr += INSN_CACHE_LINE_WIDTH;
2632 }
2633
2634 initialized = 1;
2635 }
2636
2637 /* Find the location in array that occupies the same cache line as BEG. */
2638
2639 offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
2640 start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
2641 & -INSN_CACHE_PLANE_SIZE)
2642 + offset);
2643
2644 /* Compute the cache alignment of the place to stop clearing. */
2645 #if 0 /* This is not needed for gcc's purposes. */
2646 /* If the block to clear is bigger than a cache plane,
2647 we clear the entire cache, and OFFSET is already correct. */
2648 if (end < beg + INSN_CACHE_PLANE_SIZE)
2649 #endif
2650 offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
2651 & -INSN_CACHE_LINE_WIDTH)
2652 & (INSN_CACHE_PLANE_SIZE - 1));
2653
2654 #if INSN_CACHE_DEPTH > 1
2655 end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
2656 if (end_addr <= start_addr)
2657 end_addr += INSN_CACHE_PLANE_SIZE;
2658
2659 for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
2660 {
2661 int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
2662 int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
2663
2664 while (addr != stop)
2665 {
2666 /* Call the return instruction at ADDR. */
2667 ((function_ptr) addr) ();
2668
2669 addr += INSN_CACHE_LINE_WIDTH;
2670 }
2671 }
2672 #else /* just one plane */
2673 do
2674 {
2675 /* Call the return instruction at START_ADDR. */
2676 ((function_ptr) start_addr) ();
2677
2678 start_addr += INSN_CACHE_LINE_WIDTH;
2679 }
2680 while ((start_addr % INSN_CACHE_SIZE) != offset);
2681 #endif /* just one plane */
2682 #endif /* Cache is large */
2683 #endif /* Cache exists */
2684 #endif /* CLEAR_INSN_CACHE */
2685 }
2686
2687 #endif /* L_clear_cache */
2688 \f
2689 #ifdef L_trampoline
2690
2691 /* Jump to a trampoline, loading the static chain address. */
2692
2693 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
2694
2695 long
2696 getpagesize (void)
2697 {
2698 #ifdef _ALPHA_
2699 return 8192;
2700 #else
2701 return 4096;
2702 #endif
2703 }
2704
2705 #ifdef __i386__
2706 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
2707 #endif
2708
2709 int
2710 mprotect (char *addr, int len, int prot)
2711 {
2712 int np, op;
2713
2714 if (prot == 7)
2715 np = 0x40;
2716 else if (prot == 5)
2717 np = 0x20;
2718 else if (prot == 4)
2719 np = 0x10;
2720 else if (prot == 3)
2721 np = 0x04;
2722 else if (prot == 1)
2723 np = 0x02;
2724 else if (prot == 0)
2725 np = 0x01;
2726
2727 if (VirtualProtect (addr, len, np, &op))
2728 return 0;
2729 else
2730 return -1;
2731 }
2732
2733 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
2734
2735 #ifdef TRANSFER_FROM_TRAMPOLINE
2736 TRANSFER_FROM_TRAMPOLINE
2737 #endif
2738
2739 #if defined (NeXT) && defined (__MACH__)
2740
2741 /* Make stack executable so we can call trampolines on stack.
2742 This is called from INITIALIZE_TRAMPOLINE in next.h. */
2743 #ifdef NeXTStep21
2744 #include <mach.h>
2745 #else
2746 #include <mach/mach.h>
2747 #endif
2748
2749 void
2750 __enable_execute_stack (char *addr)
2751 {
2752 kern_return_t r;
2753 char *eaddr = addr + TRAMPOLINE_SIZE;
2754 vm_address_t a = (vm_address_t) addr;
2755
2756 /* turn on execute access on stack */
2757 r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
2758 if (r != KERN_SUCCESS)
2759 {
2760 mach_error("vm_protect VM_PROT_ALL", r);
2761 exit(1);
2762 }
2763
2764 /* We inline the i-cache invalidation for speed */
2765
2766 #ifdef CLEAR_INSN_CACHE
2767 CLEAR_INSN_CACHE (addr, eaddr);
2768 #else
2769 __clear_cache ((int) addr, (int) eaddr);
2770 #endif
2771 }
2772
2773 #endif /* defined (NeXT) && defined (__MACH__) */
2774
2775 #ifdef __convex__
2776
2777 /* Make stack executable so we can call trampolines on stack.
2778 This is called from INITIALIZE_TRAMPOLINE in convex.h. */
2779
2780 #include <sys/mman.h>
2781 #include <sys/vmparam.h>
2782 #include <machine/machparam.h>
2783
2784 void
2785 __enable_execute_stack (void)
2786 {
2787 int fp;
2788 static unsigned lowest = USRSTACK;
2789 unsigned current = (unsigned) &fp & -NBPG;
2790
2791 if (lowest > current)
2792 {
2793 unsigned len = lowest - current;
2794 mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
2795 lowest = current;
2796 }
2797
2798 /* Clear instruction cache in case an old trampoline is in it. */
2799 asm ("pich");
2800 }
2801 #endif /* __convex__ */
2802
2803 #ifdef __sysV88__
2804
2805 /* Modified from the convex -code above. */
2806
2807 #include <sys/param.h>
2808 #include <errno.h>
2809 #include <sys/m88kbcs.h>
2810
2811 void
2812 __enable_execute_stack (void)
2813 {
2814 int save_errno;
2815 static unsigned long lowest = USRSTACK;
2816 unsigned long current = (unsigned long) &save_errno & -NBPC;
2817
2818 /* Ignore errno being set. memctl sets errno to EINVAL whenever the
2819 address is seen as 'negative'. That is the case with the stack. */
2820
2821 save_errno=errno;
2822 if (lowest > current)
2823 {
2824 unsigned len=lowest-current;
2825 memctl(current,len,MCT_TEXT);
2826 lowest = current;
2827 }
2828 else
2829 memctl(current,NBPC,MCT_TEXT);
2830 errno=save_errno;
2831 }
2832
2833 #endif /* __sysV88__ */
2834
2835 #ifdef __sysV68__
2836
2837 #include <sys/signal.h>
2838 #include <errno.h>
2839
2840 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
2841 so define it here, because we need it in __clear_insn_cache below */
2842 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
2843 hence we enable this stuff only if MCT_TEXT is #define'd. */
2844
2845 #ifdef MCT_TEXT
2846 asm("\n\
2847 global memctl\n\
2848 memctl:\n\
2849 movq &75,%d0\n\
2850 trap &0\n\
2851 bcc.b noerror\n\
2852 jmp cerror%\n\
2853 noerror:\n\
2854 movq &0,%d0\n\
2855 rts");
2856 #endif
2857
2858 /* Clear instruction cache so we can call trampolines on stack.
2859 This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
2860
2861 void
2862 __clear_insn_cache (void)
2863 {
2864 #ifdef MCT_TEXT
2865 int save_errno;
2866
2867 /* Preserve errno, because users would be surprised to have
2868 errno changing without explicitly calling any system-call. */
2869 save_errno = errno;
2870
2871 /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
2872 No need to use an address derived from _start or %sp, as 0 works also. */
2873 memctl(0, 4096, MCT_TEXT);
2874 errno = save_errno;
2875 #endif
2876 }
2877
2878 #endif /* __sysV68__ */
2879
2880 #ifdef __pyr__
2881
2882 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2883 #include <stdio.h>
2884 #include <sys/mman.h>
2885 #include <sys/types.h>
2886 #include <sys/param.h>
2887 #include <sys/vmmac.h>
2888
2889 /* Modified from the convex -code above.
2890 mremap promises to clear the i-cache. */
2891
2892 void
2893 __enable_execute_stack (void)
2894 {
2895 int fp;
2896 if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
2897 PROT_READ|PROT_WRITE|PROT_EXEC))
2898 {
2899 perror ("mprotect in __enable_execute_stack");
2900 fflush (stderr);
2901 abort ();
2902 }
2903 }
2904 #endif /* __pyr__ */
2905
2906 #if defined (sony_news) && defined (SYSTYPE_BSD)
2907
2908 #include <stdio.h>
2909 #include <sys/types.h>
2910 #include <sys/param.h>
2911 #include <syscall.h>
2912 #include <machine/sysnews.h>
2913
2914 /* cacheflush function for NEWS-OS 4.2.
2915 This function is called from trampoline-initialize code
2916 defined in config/mips/mips.h. */
2917
2918 void
2919 cacheflush (char *beg, int size, int flag)
2920 {
2921 if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
2922 {
2923 perror ("cache_flush");
2924 fflush (stderr);
2925 abort ();
2926 }
2927 }
2928
2929 #endif /* sony_news */
2930 #endif /* L_trampoline */
2931 \f
2932 #ifndef __CYGWIN__
2933 #ifdef L__main
2934
2935 #include "gbl-ctors.h"
2936 /* Some systems use __main in a way incompatible with its use in gcc, in these
2937 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2938 give the same symbol without quotes for an alternative entry point. You
2939 must define both, or neither. */
2940 #ifndef NAME__MAIN
2941 #define NAME__MAIN "__main"
2942 #define SYMBOL__MAIN __main
2943 #endif
2944
2945 #ifdef INIT_SECTION_ASM_OP
2946 #undef HAS_INIT_SECTION
2947 #define HAS_INIT_SECTION
2948 #endif
2949
2950 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2951
2952 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2953 code to run constructors. In that case, we need to handle EH here, too. */
2954
2955 #ifdef EH_FRAME_SECTION
2956 #include "frame.h"
2957 extern unsigned char __EH_FRAME_BEGIN__[];
2958 #endif
2959
2960 /* Run all the global destructors on exit from the program. */
2961
2962 void
2963 __do_global_dtors (void)
2964 {
2965 #ifdef DO_GLOBAL_DTORS_BODY
2966 DO_GLOBAL_DTORS_BODY;
2967 #else
2968 static func_ptr *p = __DTOR_LIST__ + 1;
2969 while (*p)
2970 {
2971 p++;
2972 (*(p-1)) ();
2973 }
2974 #endif
2975 #if defined (EH_FRAME_SECTION) && !defined (HAS_INIT_SECTION)
2976 {
2977 static int completed = 0;
2978 if (! completed)
2979 {
2980 completed = 1;
2981 __deregister_frame_info (__EH_FRAME_BEGIN__);
2982 }
2983 }
2984 #endif
2985 }
2986 #endif
2987
2988 #ifndef HAS_INIT_SECTION
2989 /* Run all the global constructors on entry to the program. */
2990
2991 void
2992 __do_global_ctors (void)
2993 {
2994 #ifdef EH_FRAME_SECTION
2995 {
2996 static struct object object;
2997 __register_frame_info (__EH_FRAME_BEGIN__, &object);
2998 }
2999 #endif
3000 DO_GLOBAL_CTORS_BODY;
3001 atexit (__do_global_dtors);
3002 }
3003 #endif /* no HAS_INIT_SECTION */
3004
3005 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
3006 /* Subroutine called automatically by `main'.
3007 Compiling a global function named `main'
3008 produces an automatic call to this function at the beginning.
3009
3010 For many systems, this routine calls __do_global_ctors.
3011 For systems which support a .init section we use the .init section
3012 to run __do_global_ctors, so we need not do anything here. */
3013
3014 void
3015 SYMBOL__MAIN ()
3016 {
3017 /* Support recursive calls to `main': run initializers just once. */
3018 static int initialized;
3019 if (! initialized)
3020 {
3021 initialized = 1;
3022 __do_global_ctors ();
3023 }
3024 }
3025 #endif /* no HAS_INIT_SECTION or INVOKE__main */
3026
3027 #endif /* L__main */
3028 #endif /* __CYGWIN__ */
3029 \f
3030 #ifdef L_ctors
3031
3032 #include "gbl-ctors.h"
3033
3034 /* Provide default definitions for the lists of constructors and
3035 destructors, so that we don't get linker errors. These symbols are
3036 intentionally bss symbols, so that gld and/or collect will provide
3037 the right values. */
3038
3039 /* We declare the lists here with two elements each,
3040 so that they are valid empty lists if no other definition is loaded.
3041
3042 If we are using the old "set" extensions to have the gnu linker
3043 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
3044 must be in the bss/common section.
3045
3046 Long term no port should use those extensions. But many still do. */
3047 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
3048 #if defined (ASM_OUTPUT_CONSTRUCTOR) || defined (USE_COLLECT2)
3049 func_ptr __CTOR_LIST__[2] = {0, 0};
3050 func_ptr __DTOR_LIST__[2] = {0, 0};
3051 #else
3052 func_ptr __CTOR_LIST__[2];
3053 func_ptr __DTOR_LIST__[2];
3054 #endif
3055 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
3056 #endif /* L_ctors */
3057 \f
3058 #ifdef L_exit
3059
3060 #include "gbl-ctors.h"
3061
3062 #ifdef NEED_ATEXIT
3063
3064 #ifndef ON_EXIT
3065
3066 # include <errno.h>
3067
3068 static func_ptr *atexit_chain = 0;
3069 static long atexit_chain_length = 0;
3070 static volatile long last_atexit_chain_slot = -1;
3071
3072 int
3073 atexit (func_ptr func)
3074 {
3075 if (++last_atexit_chain_slot == atexit_chain_length)
3076 {
3077 atexit_chain_length += 32;
3078 if (atexit_chain)
3079 atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
3080 * sizeof (func_ptr));
3081 else
3082 atexit_chain = (func_ptr *) malloc (atexit_chain_length
3083 * sizeof (func_ptr));
3084 if (! atexit_chain)
3085 {
3086 atexit_chain_length = 0;
3087 last_atexit_chain_slot = -1;
3088 errno = ENOMEM;
3089 return (-1);
3090 }
3091 }
3092 atexit_chain[last_atexit_chain_slot] = func;
3093 return (0);
3094 }
3095
3096 extern void _cleanup (void);
3097 extern void _exit (int) __attribute__ ((__noreturn__));
3098
3099 void
3100 exit (int status)
3101 {
3102 if (atexit_chain)
3103 {
3104 for ( ; last_atexit_chain_slot-- >= 0; )
3105 {
3106 (*atexit_chain[last_atexit_chain_slot + 1]) ();
3107 atexit_chain[last_atexit_chain_slot + 1] = 0;
3108 }
3109 free (atexit_chain);
3110 atexit_chain = 0;
3111 }
3112 #ifdef EXIT_BODY
3113 EXIT_BODY;
3114 #else
3115 _cleanup ();
3116 #endif
3117 _exit (status);
3118 }
3119
3120 #else /* ON_EXIT */
3121
3122 /* Simple; we just need a wrapper for ON_EXIT. */
3123 int
3124 atexit (func_ptr func)
3125 {
3126 return ON_EXIT (func);
3127 }
3128
3129 #endif /* ON_EXIT */
3130 #endif /* NEED_ATEXIT */
3131
3132 #endif /* L_exit */
3133 \f
3134 #ifdef L_eh
3135
3136 #include "gthr.h"
3137
3138 /* Shared exception handling support routines. */
3139
3140 void
3141 __default_terminate (void)
3142 {
3143 abort ();
3144 }
3145
3146 void (*__terminate_func)(void) __attribute__ ((__noreturn__)) =
3147 __default_terminate;
3148
3149 void __attribute__((__noreturn__))
3150 __terminate (void)
3151 {
3152 (*__terminate_func)();
3153 }
3154
3155 void *
3156 __throw_type_match (void *catch_type, void *throw_type, void *obj)
3157 {
3158 #if 0
3159 printf ("__throw_type_match (): catch_type = %s, throw_type = %s\n",
3160 catch_type, throw_type);
3161 #endif
3162 if (strcmp ((const char *)catch_type, (const char *)throw_type) == 0)
3163 return obj;
3164 return 0;
3165 }
3166
3167 void
3168 __empty (void)
3169 {
3170 }
3171 \f
3172
3173 /* Include definitions of EH context and table layout */
3174
3175 #include "eh-common.h"
3176 #ifndef inhibit_libc
3177 #include <stdio.h>
3178 #endif
3179
3180 /* Allocate and return a new EH context structure. */
3181
3182 #if __GTHREADS
3183 static void *
3184 new_eh_context (void)
3185 {
3186 struct eh_full_context {
3187 struct eh_context c;
3188 void *top_elt[2];
3189 } *ehfc = (struct eh_full_context *) malloc (sizeof *ehfc);
3190
3191 if (! ehfc)
3192 __terminate ();
3193
3194 memset (ehfc, 0, sizeof *ehfc);
3195
3196 ehfc->c.dynamic_handler_chain = (void **) ehfc->top_elt;
3197
3198 /* This should optimize out entirely. This should always be true,
3199 but just in case it ever isn't, don't allow bogus code to be
3200 generated. */
3201
3202 if ((void*)(&ehfc->c) != (void*)ehfc)
3203 __terminate ();
3204
3205 return &ehfc->c;
3206 }
3207
3208 static __gthread_key_t eh_context_key;
3209
3210 /* Destructor for struct eh_context. */
3211 static void
3212 eh_context_free (void *ptr)
3213 {
3214 __gthread_key_dtor (eh_context_key, ptr);
3215 if (ptr)
3216 free (ptr);
3217 }
3218 #endif
3219
3220 /* Pointer to function to return EH context. */
3221
3222 static struct eh_context *eh_context_initialize (void);
3223 static struct eh_context *eh_context_static (void);
3224 #if __GTHREADS
3225 static struct eh_context *eh_context_specific (void);
3226 #endif
3227
3228 static struct eh_context *(*get_eh_context) (void) = &eh_context_initialize;
3229
3230 /* Routine to get EH context.
3231 This one will simply call the function pointer. */
3232
3233 void *
3234 __get_eh_context (void)
3235 {
3236 return (void *) (*get_eh_context) ();
3237 }
3238
3239 /* Get and set the language specific info pointer. */
3240
3241 void **
3242 __get_eh_info (void)
3243 {
3244 struct eh_context *eh = (*get_eh_context) ();
3245 return &eh->info;
3246 }
3247 \f
3248 #ifdef DWARF2_UNWIND_INFO
3249 static int dwarf_reg_size_table_initialized = 0;
3250 static char dwarf_reg_size_table[DWARF_FRAME_REGISTERS];
3251
3252 static void
3253 init_reg_size_table (void)
3254 {
3255 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);
3256 dwarf_reg_size_table_initialized = 1;
3257 }
3258 #endif
3259
3260 #if __GTHREADS
3261 static void
3262 eh_threads_initialize (void)
3263 {
3264 /* Try to create the key. If it fails, revert to static method,
3265 otherwise start using thread specific EH contexts. */
3266 if (__gthread_key_create (&eh_context_key, &eh_context_free) == 0)
3267 get_eh_context = &eh_context_specific;
3268 else
3269 get_eh_context = &eh_context_static;
3270 }
3271 #endif /* no __GTHREADS */
3272
3273 /* Initialize EH context.
3274 This will be called only once, since we change GET_EH_CONTEXT
3275 pointer to another routine. */
3276
3277 static struct eh_context *
3278 eh_context_initialize (void)
3279 {
3280 #if __GTHREADS
3281
3282 static __gthread_once_t once = __GTHREAD_ONCE_INIT;
3283 /* Make sure that get_eh_context does not point to us anymore.
3284 Some systems have dummy thread routines in their libc that
3285 return a success (Solaris 2.6 for example). */
3286 if (__gthread_once (&once, eh_threads_initialize) != 0
3287 || get_eh_context == &eh_context_initialize)
3288 {
3289 /* Use static version of EH context. */
3290 get_eh_context = &eh_context_static;
3291 }
3292 #ifdef DWARF2_UNWIND_INFO
3293 {
3294 static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
3295 if (__gthread_once (&once_regsizes, init_reg_size_table) != 0
3296 || ! dwarf_reg_size_table_initialized)
3297 init_reg_size_table ();
3298 }
3299 #endif
3300
3301 #else /* no __GTHREADS */
3302
3303 /* Use static version of EH context. */
3304 get_eh_context = &eh_context_static;
3305
3306 #ifdef DWARF2_UNWIND_INFO
3307 init_reg_size_table ();
3308 #endif
3309
3310 #endif /* no __GTHREADS */
3311
3312 return (*get_eh_context) ();
3313 }
3314
3315 /* Return a static EH context. */
3316
3317 static struct eh_context *
3318 eh_context_static (void)
3319 {
3320 static struct eh_context eh;
3321 static int initialized;
3322 static void *top_elt[2];
3323
3324 if (! initialized)
3325 {
3326 initialized = 1;
3327 memset (&eh, 0, sizeof eh);
3328 eh.dynamic_handler_chain = top_elt;
3329 }
3330 return &eh;
3331 }
3332
3333 #if __GTHREADS
3334 /* Return a thread specific EH context. */
3335
3336 static struct eh_context *
3337 eh_context_specific (void)
3338 {
3339 struct eh_context *eh;
3340 eh = (struct eh_context *) __gthread_getspecific (eh_context_key);
3341 if (! eh)
3342 {
3343 eh = new_eh_context ();
3344 if (__gthread_setspecific (eh_context_key, (void *) eh) != 0)
3345 __terminate ();
3346 }
3347
3348 return eh;
3349 }
3350 #endif /* __GTHREADS */
3351 \f
3352 /* Support routines for alloc/free during exception handling */
3353
3354 /* __eh_alloc and __eh_free attempt allocation using malloc, but fall back to
3355 the small arena in the eh_context. This is needed because throwing an
3356 out-of-memory exception would fail otherwise. The emergency space is
3357 allocated in blocks of size EH_ALLOC_ALIGN, the
3358 minimum allocation being two blocks. A bitmask indicates which blocks
3359 have been allocated. To indicate the size of an allocation, the bit for
3360 the final block is not set. Hence each allocation is a run of 1s followed
3361 by a zero. */
3362 void *
3363 __eh_alloc (size_t size)
3364 {
3365 void *p;
3366
3367 if (!size)
3368 abort();
3369 p = malloc (size);
3370 if (p == 0)
3371 {
3372 struct eh_context *eh = __get_eh_context ();
3373 unsigned blocks = (size + EH_ALLOC_ALIGN - 1) / EH_ALLOC_ALIGN;
3374 unsigned real_mask = eh->alloc_mask | (eh->alloc_mask << 1);
3375 unsigned our_mask;
3376 unsigned ix;
3377
3378 if (blocks > EH_ALLOC_SIZE / EH_ALLOC_ALIGN)
3379 __terminate ();
3380 blocks += blocks == 1;
3381 our_mask = (1 << blocks) - 1;
3382
3383 for (ix = EH_ALLOC_SIZE / EH_ALLOC_ALIGN - blocks; ix; ix--)
3384 if (! ((real_mask >> ix) & our_mask))
3385 {
3386 /* found some space */
3387 p = &eh->alloc_buffer[ix * EH_ALLOC_ALIGN];
3388 eh->alloc_mask |= (our_mask >> 1) << ix;
3389 return p;
3390 }
3391 __terminate ();
3392 }
3393 return p;
3394 }
3395
3396 /* Free the memory for an cp_eh_info and associated exception, given
3397 a pointer to the cp_eh_info. */
3398 void
3399 __eh_free (void *p)
3400 {
3401 struct eh_context *eh = __get_eh_context ();
3402
3403 ptrdiff_t diff = (char *)p - &eh->alloc_buffer[0];
3404 if (diff >= 0 && diff < EH_ALLOC_SIZE)
3405 {
3406 unsigned mask = eh->alloc_mask;
3407 unsigned bit = 1 << (diff / EH_ALLOC_ALIGN);
3408
3409 do
3410 {
3411 mask ^= bit;
3412 bit <<= 1;
3413 }
3414 while (mask & bit);
3415 eh->alloc_mask = mask;
3416 }
3417 else
3418 free (p);
3419 }
3420 \f
3421 /* Support routines for setjmp/longjmp exception handling. */
3422
3423 /* Calls to __sjthrow are generated by the compiler when an exception
3424 is raised when using the setjmp/longjmp exception handling codegen
3425 method. */
3426
3427 #ifdef DONT_USE_BUILTIN_SETJMP
3428 extern void longjmp (void *, int);
3429 #endif
3430
3431 /* Routine to get the head of the current thread's dynamic handler chain
3432 use for exception handling. */
3433
3434 void ***
3435 __get_dynamic_handler_chain (void)
3436 {
3437 struct eh_context *eh = (*get_eh_context) ();
3438 return &eh->dynamic_handler_chain;
3439 }
3440
3441 /* This is used to throw an exception when the setjmp/longjmp codegen
3442 method is used for exception handling.
3443
3444 We call __terminate if there are no handlers left. Otherwise we run the
3445 cleanup actions off the dynamic cleanup stack, and pop the top of the
3446 dynamic handler chain, and use longjmp to transfer back to the associated
3447 handler. */
3448
3449 void
3450 __sjthrow (void)
3451 {
3452 struct eh_context *eh = (*get_eh_context) ();
3453 void ***dhc = &eh->dynamic_handler_chain;
3454 void *jmpbuf;
3455 void (*func)(void *, int);
3456 void *arg;
3457 /* The cleanup chain is one word into the buffer. Get the cleanup chain. */
3458 void ***cleanup = (void***)&(*dhc)[1];
3459
3460 /* If there are any cleanups in the chain, run them now. */
3461 if (cleanup[0])
3462 {
3463 double store[200];
3464 void **buf = (void**)store;
3465 buf[1] = 0;
3466 buf[0] = (*dhc);
3467
3468 /* try { */
3469 #ifdef DONT_USE_BUILTIN_SETJMP
3470 if (! setjmp (&buf[2]))
3471 #else
3472 if (! __builtin_setjmp (&buf[2]))
3473 #endif
3474 {
3475 *dhc = buf;
3476 while (cleanup[0])
3477 {
3478 func = (void(*)(void*, int))cleanup[0][1];
3479 arg = (void*)cleanup[0][2];
3480
3481 /* Update this before running the cleanup. */
3482 cleanup[0] = (void **)cleanup[0][0];
3483
3484 (*func)(arg, 2);
3485 }
3486 *dhc = buf[0];
3487 }
3488 /* catch (...) */
3489 else
3490 {
3491 __terminate ();
3492 }
3493 }
3494
3495 /* We must call terminate if we try and rethrow an exception, when
3496 there is no exception currently active and when there are no
3497 handlers left. */
3498 if (! eh->info || (*dhc)[0] == 0)
3499 __terminate ();
3500
3501 /* Find the jmpbuf associated with the top element of the dynamic
3502 handler chain. The jumpbuf starts two words into the buffer. */
3503 jmpbuf = &(*dhc)[2];
3504
3505 /* Then we pop the top element off the dynamic handler chain. */
3506 *dhc = (void**)(*dhc)[0];
3507
3508 /* And then we jump to the handler. */
3509
3510 #ifdef DONT_USE_BUILTIN_SETJMP
3511 longjmp (jmpbuf, 1);
3512 #else
3513 __builtin_longjmp (jmpbuf, 1);
3514 #endif
3515 }
3516
3517 /* Run cleanups on the dynamic cleanup stack for the current dynamic
3518 handler, then pop the handler off the dynamic handler stack, and
3519 then throw. This is used to skip the first handler, and transfer
3520 control to the next handler in the dynamic handler stack. */
3521
3522 void
3523 __sjpopnthrow (void)
3524 {
3525 struct eh_context *eh = (*get_eh_context) ();
3526 void ***dhc = &eh->dynamic_handler_chain;
3527 void (*func)(void *, int);
3528 void *arg;
3529 /* The cleanup chain is one word into the buffer. Get the cleanup chain. */
3530 void ***cleanup = (void***)&(*dhc)[1];
3531
3532 /* If there are any cleanups in the chain, run them now. */
3533 if (cleanup[0])
3534 {
3535 double store[200];
3536 void **buf = (void**)store;
3537 buf[1] = 0;
3538 buf[0] = (*dhc);
3539
3540 /* try { */
3541 #ifdef DONT_USE_BUILTIN_SETJMP
3542 if (! setjmp (&buf[2]))
3543 #else
3544 if (! __builtin_setjmp (&buf[2]))
3545 #endif
3546 {
3547 *dhc = buf;
3548 while (cleanup[0])
3549 {
3550 func = (void(*)(void*, int))cleanup[0][1];
3551 arg = (void*)cleanup[0][2];
3552
3553 /* Update this before running the cleanup. */
3554 cleanup[0] = (void **)cleanup[0][0];
3555
3556 (*func)(arg, 2);
3557 }
3558 *dhc = buf[0];
3559 }
3560 /* catch (...) */
3561 else
3562 {
3563 __terminate ();
3564 }
3565 }
3566
3567 /* Then we pop the top element off the dynamic handler chain. */
3568 *dhc = (void**)(*dhc)[0];
3569
3570 __sjthrow ();
3571 }
3572 \f
3573 /* Support code for all exception region-based exception handling. */
3574
3575 int
3576 __eh_rtime_match (void *rtime)
3577 {
3578 void *info;
3579 __eh_matcher matcher;
3580 void *ret;
3581
3582 info = *(__get_eh_info ());
3583 matcher = ((__eh_info *)info)->match_function;
3584 if (! matcher)
3585 {
3586 #ifndef inhibit_libc
3587 fprintf (stderr, "Internal Compiler Bug: No runtime type matcher.");
3588 #endif
3589 return 0;
3590 }
3591 ret = (*matcher) (info, rtime, (void *)0);
3592 return (ret != NULL);
3593 }
3594
3595 /* This value identifies the place from which an exception is being
3596 thrown. */
3597
3598 #ifdef EH_TABLE_LOOKUP
3599
3600 EH_TABLE_LOOKUP
3601
3602 #else
3603
3604 #ifdef DWARF2_UNWIND_INFO
3605
3606 /* Return the table version of an exception descriptor */
3607
3608 short
3609 __get_eh_table_version (exception_descriptor *table)
3610 {
3611 return table->lang.version;
3612 }
3613
3614 /* Return the originating table language of an exception descriptor */
3615
3616 short
3617 __get_eh_table_language (exception_descriptor *table)
3618 {
3619 return table->lang.language;
3620 }
3621
3622 /* This routine takes a PC and a pointer to the exception region TABLE for
3623 its translation unit, and returns the address of the exception handler
3624 associated with the closest exception table handler entry associated
3625 with that PC, or 0 if there are no table entries the PC fits in.
3626
3627 In the advent of a tie, we have to give the last entry, as it represents
3628 an inner block. */
3629
3630 static void *
3631 old_find_exception_handler (void *pc, old_exception_table *table)
3632 {
3633 if (table)
3634 {
3635 int pos;
3636 int best = -1;
3637
3638 /* We can't do a binary search because the table isn't guaranteed
3639 to be sorted from function to function. */
3640 for (pos = 0; table[pos].start_region != (void *) -1; ++pos)
3641 {
3642 if (table[pos].start_region <= pc && table[pos].end_region > pc)
3643 {
3644 /* This can apply. Make sure it is at least as small as
3645 the previous best. */
3646 if (best == -1 || (table[pos].end_region <= table[best].end_region
3647 && table[pos].start_region >= table[best].start_region))
3648 best = pos;
3649 }
3650 /* But it is sorted by starting PC within a function. */
3651 else if (best >= 0 && table[pos].start_region > pc)
3652 break;
3653 }
3654 if (best != -1)
3655 return table[best].exception_handler;
3656 }
3657
3658 return (void *) 0;
3659 }
3660
3661 /* find_exception_handler finds the correct handler, if there is one, to
3662 handle an exception.
3663 returns a pointer to the handler which controlled should be transferred
3664 to, or NULL if there is nothing left.
3665 Parameters:
3666 PC - pc where the exception originates. If this is a rethrow,
3667 then this starts out as a pointer to the exception table
3668 entry we wish to rethrow out of.
3669 TABLE - exception table for the current module.
3670 EH_INFO - eh info pointer for this exception.
3671 RETHROW - 1 if this is a rethrow. (see incoming value of PC).
3672 CLEANUP - returned flag indicating whether this is a cleanup handler.
3673 */
3674 static void *
3675 find_exception_handler (void *pc, exception_descriptor *table,
3676 __eh_info *eh_info, int rethrow, int *cleanup)
3677 {
3678
3679 void *retval = NULL;
3680 *cleanup = 1;
3681 if (table)
3682 {
3683 int pos = 0;
3684 /* The new model assumed the table is sorted inner-most out so the
3685 first region we find which matches is the correct one */
3686
3687 exception_table *tab = &(table->table[0]);
3688
3689 /* Subtract 1 from the PC to avoid hitting the next region */
3690 if (rethrow)
3691 {
3692 /* pc is actually the region table entry to rethrow out of */
3693 pos = ((exception_table *) pc) - tab;
3694 pc = ((exception_table *) pc)->end_region - 1;
3695
3696 /* The label is always on the LAST handler entry for a region,
3697 so we know the next entry is a different region, even if the
3698 addresses are the same. Make sure its not end of table tho. */
3699 if (tab[pos].start_region != (void *) -1)
3700 pos++;
3701 }
3702 else
3703 pc--;
3704
3705 /* We can't do a binary search because the table is in inner-most
3706 to outermost address ranges within functions */
3707 for ( ; tab[pos].start_region != (void *) -1; pos++)
3708 {
3709 if (tab[pos].start_region <= pc && tab[pos].end_region > pc)
3710 {
3711 if (tab[pos].match_info)
3712 {
3713 __eh_matcher matcher = eh_info->match_function;
3714 /* match info but no matcher is NOT a match */
3715 if (matcher)
3716 {
3717 void *ret = (*matcher)((void *) eh_info,
3718 tab[pos].match_info, table);
3719 if (ret)
3720 {
3721 if (retval == NULL)
3722 retval = tab[pos].exception_handler;
3723 *cleanup = 0;
3724 break;
3725 }
3726 }
3727 }
3728 else
3729 {
3730 if (retval == NULL)
3731 retval = tab[pos].exception_handler;
3732 }
3733 }
3734 }
3735 }
3736 return retval;
3737 }
3738 #endif /* DWARF2_UNWIND_INFO */
3739 #endif /* EH_TABLE_LOOKUP */
3740 \f
3741 #ifdef DWARF2_UNWIND_INFO
3742 /* Support code for exception handling using static unwind information. */
3743
3744 #include "frame.h"
3745
3746 /* This type is used in get_reg and put_reg to deal with ABIs where a void*
3747 is smaller than a word, such as the Irix 6 n32 ABI. We cast twice to
3748 avoid a warning about casting between int and pointer of different
3749 sizes. */
3750
3751 typedef int ptr_type __attribute__ ((mode (pointer)));
3752
3753 #ifdef INCOMING_REGNO
3754 /* Is the saved value for register REG in frame UDATA stored in a register
3755 window in the previous frame? */
3756
3757 /* ??? The Sparc INCOMING_REGNO references TARGET_FLAT. This allows us
3758 to use the macro here. One wonders, though, that perhaps TARGET_FLAT
3759 compiled functions won't work with the frame-unwind stuff here.
3760 Perhaps the entireity of in_reg_window should be conditional on having
3761 seen a DW_CFA_GNU_window_save? */
3762 #define target_flags 0
3763
3764 static int
3765 in_reg_window (int reg, frame_state *udata)
3766 {
3767 if (udata->saved[reg] == REG_SAVED_REG)
3768 return INCOMING_REGNO (reg) == reg;
3769 if (udata->saved[reg] != REG_SAVED_OFFSET)
3770 return 0;
3771
3772 #ifdef STACK_GROWS_DOWNWARD
3773 return udata->reg_or_offset[reg] > 0;
3774 #else
3775 return udata->reg_or_offset[reg] < 0;
3776 #endif
3777 }
3778 #else
3779 static inline int
3780 in_reg_window (int reg __attribute__ ((__unused__)),
3781 frame_state *udata __attribute__ ((__unused__)))
3782 {
3783 return 0;
3784 }
3785 #endif /* INCOMING_REGNO */
3786
3787 /* Get the address of register REG as saved in UDATA, where SUB_UDATA is a
3788 frame called by UDATA or 0. */
3789
3790 static word_type *
3791 get_reg_addr (unsigned reg, frame_state *udata, frame_state *sub_udata)
3792 {
3793 while (udata->saved[reg] == REG_SAVED_REG)
3794 {
3795 reg = udata->reg_or_offset[reg];
3796 if (in_reg_window (reg, udata))
3797 {
3798 udata = sub_udata;
3799 sub_udata = NULL;
3800 }
3801 }
3802 if (udata->saved[reg] == REG_SAVED_OFFSET)
3803 return (word_type *)(udata->cfa + udata->reg_or_offset[reg]);
3804 else
3805 abort ();
3806 }
3807
3808 /* Get the value of register REG as saved in UDATA, where SUB_UDATA is a
3809 frame called by UDATA or 0. */
3810
3811 static inline void *
3812 get_reg (unsigned reg, frame_state *udata, frame_state *sub_udata)
3813 {
3814 return (void *)(ptr_type) *get_reg_addr (reg, udata, sub_udata);
3815 }
3816
3817 /* Overwrite the saved value for register REG in frame UDATA with VAL. */
3818
3819 static inline void
3820 put_reg (unsigned reg, void *val, frame_state *udata)
3821 {
3822 *get_reg_addr (reg, udata, NULL) = (word_type)(ptr_type) val;
3823 }
3824
3825 /* Copy the saved value for register REG from frame UDATA to frame
3826 TARGET_UDATA. Unlike the previous two functions, this can handle
3827 registers that are not one word large. */
3828
3829 static void
3830 copy_reg (unsigned reg, frame_state *udata, frame_state *target_udata)
3831 {
3832 word_type *preg = get_reg_addr (reg, udata, NULL);
3833 word_type *ptreg = get_reg_addr (reg, target_udata, NULL);
3834
3835 memcpy (ptreg, preg, dwarf_reg_size_table [reg]);
3836 }
3837
3838 /* Retrieve the return address for frame UDATA. */
3839
3840 static inline void *
3841 get_return_addr (frame_state *udata, frame_state *sub_udata)
3842 {
3843 return __builtin_extract_return_addr
3844 (get_reg (udata->retaddr_column, udata, sub_udata));
3845 }
3846
3847 /* Overwrite the return address for frame UDATA with VAL. */
3848
3849 static inline void
3850 put_return_addr (void *val, frame_state *udata)
3851 {
3852 val = __builtin_frob_return_addr (val);
3853 put_reg (udata->retaddr_column, val, udata);
3854 }
3855
3856 /* Given the current frame UDATA and its return address PC, return the
3857 information about the calling frame in CALLER_UDATA. */
3858
3859 static void *
3860 next_stack_level (void *pc, frame_state *udata, frame_state *caller_udata)
3861 {
3862 caller_udata = __frame_state_for (pc, caller_udata);
3863 if (! caller_udata)
3864 return 0;
3865
3866 /* Now go back to our caller's stack frame. If our caller's CFA register
3867 was saved in our stack frame, restore it; otherwise, assume the CFA
3868 register is SP and restore it to our CFA value. */
3869 if (udata->saved[caller_udata->cfa_reg])
3870 caller_udata->cfa = get_reg (caller_udata->cfa_reg, udata, 0);
3871 else
3872 caller_udata->cfa = udata->cfa;
3873 if (caller_udata->indirect)
3874 caller_udata->cfa = * (void **) ((unsigned char *)caller_udata->cfa
3875 + caller_udata->base_offset);
3876 caller_udata->cfa += caller_udata->cfa_offset;
3877
3878 return caller_udata;
3879 }
3880
3881 /* Hook to call before __terminate if only cleanup handlers remain. */
3882 void
3883 __unwinding_cleanup (void)
3884 {
3885 }
3886
3887 /* throw_helper performs some of the common grunt work for a throw. This
3888 routine is called by throw and rethrows. This is pretty much split
3889 out from the old __throw routine. An addition has been added which allows
3890 for a dummy call to a routine __unwinding_cleanup() when there are nothing
3891 but cleanups remaining. This allows a debugger to examine the state
3892 at which the throw was executed, before any cleanups, rather than
3893 at the terminate point after the stack has been unwound.
3894
3895 EH is the current eh_context structure.
3896 PC is the address of the call to __throw.
3897 MY_UDATA is the unwind information for __throw.
3898 OFFSET_P is where we return the SP adjustment offset. */
3899
3900 static void *
3901 throw_helper (struct eh_context *eh, void *pc, frame_state *my_udata,
3902 long *offset_p)
3903 {
3904 frame_state ustruct2, *udata = &ustruct2;
3905 frame_state ustruct;
3906 frame_state *sub_udata = &ustruct;
3907 void *saved_pc = pc;
3908 void *handler;
3909 void *handler_p = 0;
3910 void *pc_p = 0;
3911 frame_state saved_ustruct;
3912 int new_eh_model;
3913 int cleanup = 0;
3914 int only_cleanup = 0;
3915 int rethrow = 0;
3916 int saved_state = 0;
3917 long args_size;
3918 __eh_info *eh_info = (__eh_info *)eh->info;
3919
3920 /* Do we find a handler based on a re-throw PC? */
3921 if (eh->table_index != (void *) 0)
3922 rethrow = 1;
3923
3924 memcpy (udata, my_udata, sizeof (*udata));
3925
3926 handler = (void *) 0;
3927 for (;;)
3928 {
3929 frame_state *p = udata;
3930 udata = next_stack_level (pc, udata, sub_udata);
3931 sub_udata = p;
3932
3933 /* If we couldn't find the next frame, we lose. */
3934 if (! udata)
3935 break;
3936
3937 if (udata->eh_ptr == NULL)
3938 new_eh_model = 0;
3939 else
3940 new_eh_model = (((exception_descriptor *)(udata->eh_ptr))->
3941 runtime_id_field == NEW_EH_RUNTIME);
3942
3943 if (rethrow)
3944 {
3945 rethrow = 0;
3946 handler = find_exception_handler (eh->table_index, udata->eh_ptr,
3947 eh_info, 1, &cleanup);
3948 eh->table_index = (void *)0;
3949 }
3950 else
3951 if (new_eh_model)
3952 handler = find_exception_handler (pc, udata->eh_ptr, eh_info,
3953 0, &cleanup);
3954 else
3955 handler = old_find_exception_handler (pc, udata->eh_ptr);
3956
3957 /* If we found one, we can stop searching, if its not a cleanup.
3958 for cleanups, we save the state, and keep looking. This allows
3959 us to call a debug hook if there are nothing but cleanups left. */
3960 if (handler)
3961 {
3962 if (cleanup)
3963 {
3964 if (!saved_state)
3965 {
3966 saved_ustruct = *udata;
3967 handler_p = handler;
3968 pc_p = pc;
3969 saved_state = 1;
3970 only_cleanup = 1;
3971 }
3972 }
3973 else
3974 {
3975 only_cleanup = 0;
3976 break;
3977 }
3978 }
3979
3980 /* Otherwise, we continue searching. We subtract 1 from PC to avoid
3981 hitting the beginning of the next region. */
3982 pc = get_return_addr (udata, sub_udata) - 1;
3983 }
3984
3985 if (saved_state)
3986 {
3987 udata = &saved_ustruct;
3988 handler = handler_p;
3989 pc = pc_p;
3990 if (only_cleanup)
3991 __unwinding_cleanup ();
3992 }
3993
3994 /* If we haven't found a handler by now, this is an unhandled
3995 exception. */
3996 if (! handler)
3997 __terminate();
3998
3999 eh->handler_label = handler;
4000
4001 args_size = udata->args_size;
4002
4003 if (pc == saved_pc)
4004 /* We found a handler in the throw context, no need to unwind. */
4005 udata = my_udata;
4006 else
4007 {
4008 int i;
4009
4010 /* Unwind all the frames between this one and the handler by copying
4011 their saved register values into our register save slots. */
4012
4013 /* Remember the PC where we found the handler. */
4014 void *handler_pc = pc;
4015
4016 /* Start from the throw context again. */
4017 pc = saved_pc;
4018 memcpy (udata, my_udata, sizeof (*udata));
4019
4020 while (pc != handler_pc)
4021 {
4022 frame_state *p = udata;
4023 udata = next_stack_level (pc, udata, sub_udata);
4024 sub_udata = p;
4025
4026 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
4027 if (i != udata->retaddr_column && udata->saved[i])
4028 {
4029 /* If you modify the saved value of the return address
4030 register on the SPARC, you modify the return address for
4031 your caller's frame. Don't do that here, as it will
4032 confuse get_return_addr. */
4033 if (in_reg_window (i, udata)
4034 && udata->saved[udata->retaddr_column] == REG_SAVED_REG
4035 && udata->reg_or_offset[udata->retaddr_column] == i)
4036 continue;
4037 copy_reg (i, udata, my_udata);
4038 }
4039
4040 pc = get_return_addr (udata, sub_udata) - 1;
4041 }
4042
4043 /* But we do need to update the saved return address register from
4044 the last frame we unwind, or the handler frame will have the wrong
4045 return address. */
4046 if (udata->saved[udata->retaddr_column] == REG_SAVED_REG)
4047 {
4048 i = udata->reg_or_offset[udata->retaddr_column];
4049 if (in_reg_window (i, udata))
4050 copy_reg (i, udata, my_udata);
4051 }
4052 }
4053 /* udata now refers to the frame called by the handler frame. */
4054
4055 /* We adjust SP by the difference between __throw's CFA and the CFA for
4056 the frame called by the handler frame, because those CFAs correspond
4057 to the SP values at the two call sites. We need to further adjust by
4058 the args_size of the handler frame itself to get the handler frame's
4059 SP from before the args were pushed for that call. */
4060 #ifdef STACK_GROWS_DOWNWARD
4061 *offset_p = udata->cfa - my_udata->cfa + args_size;
4062 #else
4063 *offset_p = my_udata->cfa - udata->cfa - args_size;
4064 #endif
4065
4066 return handler;
4067 }
4068
4069
4070 /* We first search for an exception handler, and if we don't find
4071 it, we call __terminate on the current stack frame so that we may
4072 use the debugger to walk the stack and understand why no handler
4073 was found.
4074
4075 If we find one, then we unwind the frames down to the one that
4076 has the handler and transfer control into the handler. */
4077
4078 /*extern void __throw(void) __attribute__ ((__noreturn__));*/
4079
4080 void
4081 __throw (void)
4082 {
4083 struct eh_context *eh = (*get_eh_context) ();
4084 void *pc, *handler;
4085 long offset;
4086
4087 /* XXX maybe make my_ustruct static so we don't have to look it up for
4088 each throw. */
4089 frame_state my_ustruct, *my_udata = &my_ustruct;
4090
4091 /* This is required for C++ semantics. We must call terminate if we
4092 try and rethrow an exception, when there is no exception currently
4093 active. */
4094 if (! eh->info)
4095 __terminate ();
4096
4097 /* Start at our stack frame. */
4098 label:
4099 my_udata = __frame_state_for (&&label, my_udata);
4100 if (! my_udata)
4101 __terminate ();
4102
4103 /* We need to get the value from the CFA register. */
4104 my_udata->cfa = __builtin_dwarf_cfa ();
4105
4106 /* Do any necessary initialization to access arbitrary stack frames.
4107 On the SPARC, this means flushing the register windows. */
4108 __builtin_unwind_init ();
4109
4110 /* Now reset pc to the right throw point. */
4111 pc = __builtin_extract_return_addr (__builtin_return_address (0)) - 1;
4112
4113 handler = throw_helper (eh, pc, my_udata, &offset);
4114
4115 /* Now go! */
4116
4117 __builtin_eh_return ((void *)eh, offset, handler);
4118
4119 /* Epilogue: restore the handler frame's register values and return
4120 to the stub. */
4121 }
4122
4123 /*extern void __rethrow(void *) __attribute__ ((__noreturn__));*/
4124
4125 void
4126 __rethrow (void *index)
4127 {
4128 struct eh_context *eh = (*get_eh_context) ();
4129 void *pc, *handler;
4130 long offset;
4131
4132 /* XXX maybe make my_ustruct static so we don't have to look it up for
4133 each throw. */
4134 frame_state my_ustruct, *my_udata = &my_ustruct;
4135
4136 /* This is required for C++ semantics. We must call terminate if we
4137 try and rethrow an exception, when there is no exception currently
4138 active. */
4139 if (! eh->info)
4140 __terminate ();
4141
4142 /* This is the table index we want to rethrow from. The value of
4143 the END_REGION label is used for the PC of the throw, and the
4144 search begins with the next table entry. */
4145 eh->table_index = index;
4146
4147 /* Start at our stack frame. */
4148 label:
4149 my_udata = __frame_state_for (&&label, my_udata);
4150 if (! my_udata)
4151 __terminate ();
4152
4153 /* We need to get the value from the CFA register. */
4154 my_udata->cfa = __builtin_dwarf_cfa ();
4155
4156 /* Do any necessary initialization to access arbitrary stack frames.
4157 On the SPARC, this means flushing the register windows. */
4158 __builtin_unwind_init ();
4159
4160 /* Now reset pc to the right throw point. */
4161 pc = __builtin_extract_return_addr (__builtin_return_address (0)) - 1;
4162
4163 handler = throw_helper (eh, pc, my_udata, &offset);
4164
4165 /* Now go! */
4166
4167 __builtin_eh_return ((void *)eh, offset, handler);
4168
4169 /* Epilogue: restore the handler frame's register values and return
4170 to the stub. */
4171 }
4172 #endif /* DWARF2_UNWIND_INFO */
4173
4174 #ifdef IA64_UNWIND_INFO
4175 #include "frame.h"
4176
4177 /* Return handler to which we want to transfer control, NULL if we don't
4178 intend to handle this exception here. */
4179 void *
4180 __ia64_personality_v1 (void *pc, old_exception_table *table)
4181 {
4182 if (table)
4183 {
4184 int pos;
4185 int best = -1;
4186
4187 for (pos = 0; table[pos].start_region != (void *) -1; ++pos)
4188 {
4189 if (table[pos].start_region <= pc && table[pos].end_region > pc)
4190 {
4191 /* This can apply. Make sure it is at least as small as
4192 the previous best. */
4193 if (best == -1 || (table[pos].end_region <= table[best].end_region
4194 && table[pos].start_region >= table[best].start_region))
4195 best = pos;
4196 }
4197 /* It is sorted by starting PC within a function. */
4198 else if (best >= 0 && table[pos].start_region > pc)
4199 break;
4200 }
4201 if (best != -1)
4202 return table[best].exception_handler;
4203 }
4204 return (void *) 0;
4205 }
4206
4207 static void
4208 ia64_throw_helper (ia64_frame_state *throw_frame, ia64_frame_state *caller,
4209 void *throw_bsp, void *throw_sp)
4210 {
4211 void *throw_pc = __builtin_return_address (0);
4212 unwind_info_ptr *info;
4213 void *pc, *handler = NULL;
4214 void *pc_base;
4215 int frame_count;
4216 void *bsp;
4217
4218 __builtin_ia64_flushrs (); /* Make the local register stacks available. */
4219
4220 /* Start at our stack frame, get our state. */
4221 __build_ia64_frame_state (throw_pc, throw_frame, throw_bsp, throw_sp,
4222 &pc_base);
4223
4224 /* Now we have to find the proper frame for pc, and see if there
4225 is a handler for it. if not, we keep going back frames until
4226 we do find one. Otherwise we call uncaught (). */
4227
4228 frame_count = 0;
4229 memcpy (caller, throw_frame, sizeof (*caller));
4230 while (!handler)
4231 {
4232 void *(*personality) ();
4233 void *eh_table;
4234
4235 frame_count++;
4236 /* We only care about the RP right now, so we dont need to keep
4237 any other information about a call frame right now. */
4238 pc = __get_real_reg_value (&caller->rp) - 1;
4239 bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs),
4240 caller->my_bsp);
4241 info = __build_ia64_frame_state (pc, caller, bsp, caller->my_psp,
4242 &pc_base);
4243
4244 /* If we couldn't find the next frame, we lose. */
4245 if (! info)
4246 break;
4247
4248 personality = __get_personality (info);
4249 /* TODO Haven't figured out how to actually load the personality address
4250 yet, so just always default to the one we expect for now. */
4251 if (personality != 0)
4252 personality = __ia64_personality_v1;
4253 eh_table = __get_except_table (info);
4254 /* If there is no personality routine, we'll keep unwinding. */
4255 if (personality)
4256 /* Pass a segment relative PC address to the personality routine,
4257 because the unwind_info section uses segrel relocs. */
4258 handler = personality (pc - pc_base, eh_table);
4259 }
4260
4261 if (!handler)
4262 __terminate ();
4263
4264 /* Handler is a segment relative address, so we must adjust it here. */
4265 handler += (long) pc_base;
4266
4267 /* If we found a handler, we need to unwind the stack to that point.
4268 We do this by copying saved values from previous frames into the
4269 save slot for the throw_frame saved slots. when __throw returns,
4270 it'll pickup the correct values. */
4271
4272 /* Start with where __throw saved things, and copy each saved register
4273 of each previous frame until we get to the one before we're
4274 throwing back to. */
4275 memcpy (caller, throw_frame, sizeof (*caller));
4276 for ( ; frame_count > 0; frame_count--)
4277 {
4278 pc = __get_real_reg_value (&caller->rp) - 1;
4279 bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs),
4280 caller->my_bsp);
4281 __build_ia64_frame_state (pc, caller, bsp, caller->my_psp, &pc_base);
4282 /* Any regs that were saved can be put in the throw frame now. */
4283 /* We don't want to copy any saved register from the
4284 target destination, but we do want to load up it's frame. */
4285 if (frame_count > 1)
4286 __copy_saved_reg_state (throw_frame, caller);
4287 }
4288
4289 /* Set return address of the throw frame to the handler. */
4290 __set_real_reg_value (&throw_frame->rp, handler);
4291
4292 /* TODO, do we need to do anything to make the values we wrote 'stick'? */
4293 /* DO we need to go through the whole loadrs seqeunce? */
4294 }
4295
4296
4297 void
4298 __throw ()
4299 {
4300 register void *stack_pointer __asm__("r12");
4301 struct eh_context *eh = (*get_eh_context) ();
4302 ia64_frame_state my_frame;
4303 ia64_frame_state originator; /* For the context handler is in. */
4304 void *bsp, *tmp_bsp;
4305 long offset;
4306
4307 /* This is required for C++ semantics. We must call terminate if we
4308 try and rethrow an exception, when there is no exception currently
4309 active. */
4310 if (! eh->info)
4311 __terminate ();
4312
4313 __builtin_unwind_init ();
4314
4315 /* We have to call another routine to actually process the frame
4316 information, which will force all of __throw's local registers into
4317 backing store. */
4318
4319 /* Get the value of ar.bsp while we're here. */
4320
4321 bsp = __builtin_ia64_bsp ();
4322 ia64_throw_helper (&my_frame, &originator, bsp, stack_pointer);
4323
4324 /* Now we have to fudge the bsp by the amount in our (__throw)
4325 frame marker, since the return is going to adjust it by that much. */
4326
4327 tmp_bsp = __calc_caller_bsp ((long)__get_real_reg_value (&my_frame.pfs),
4328 my_frame.my_bsp);
4329 offset = (char *)my_frame.my_bsp - (char *)tmp_bsp;
4330 tmp_bsp = (char *)originator.my_bsp + offset;
4331
4332 __builtin_eh_return (tmp_bsp, offset, originator.my_sp);
4333
4334 /* The return address was already set by throw_helper. */
4335 }
4336
4337 #endif /* IA64_UNWIND_INFO */
4338
4339 #endif /* L_eh */
Mirror of the offical gcc git repository hosted at gcc.gnu.org