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