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