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