![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libgcc2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to libgcc2.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* More subroutines needed by GCC output code on some machines. */
2: /* Compile this one with gcc. */
3: /* Copyright (C) 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21: /* As a special exception, if you link this library with files
22: compiled with GCC to produce an executable, this does not cause
23: the resulting executable to be covered by the GNU General Public License.
24: This exception does not however invalidate any other reasons why
25: the executable file might be covered by the GNU General Public License. */
26:
27: /* It is incorrect to include config.h here, because this file is being
28: compiled for the target, and hence definitions concerning only the host
29: do not apply. */
30:
31: #include "tconfig.h"
32: #include "machmode.h"
33: #ifndef L_trampoline
34: #include "gstddef.h"
35: #endif
36: #ifdef SHLIB
37: #include <libsys/shlib.h>
38: extern void* malloc (int);
39: extern int write (int, const char*, int);
40: extern void free (void*);
41: #endif
42:
43: /* Don't use `fancy_abort' here even if config.h says to use it. */
44: #ifdef abort
45: #undef abort
46: #endif
47:
48: /* In the first part of this file, we are interfacing to calls generated
49: by the compiler itself. These calls pass values into these routines
50: which have very specific modes (rather than very specific types), and
51: these compiler-generated calls also expect any return values to have
52: very specific modes (rather than very specific types). Thus, we need
53: to avoid using regular C language type names in this part of the file
54: because the sizes for those types can be configured to be anything.
55: Instead we use the following special type names. */
56:
57: typedef unsigned int UQItype __attribute__ ((mode (QI)));
58: typedef int SItype __attribute__ ((mode (SI)));
59: typedef unsigned int USItype __attribute__ ((mode (SI)));
60: typedef int DItype __attribute__ ((mode (DI)));
61: typedef unsigned int UDItype __attribute__ ((mode (DI)));
62: typedef float SFtype __attribute__ ((mode (SF)));
63: typedef float DFtype __attribute__ ((mode (DF)));
64: #if LONG_DOUBLE_TYPE_SIZE == 96
65: typedef float XFtype __attribute__ ((mode (XF)));
66: #endif
67: #if LONG_DOUBLE_TYPE_SIZE == 128
68: typedef float TFtype __attribute__ ((mode (TF)));
69: #endif
70:
71: #if BITS_PER_WORD==16
72: typedef int word_type __attribute__ ((mode (HI)));
73: #endif
74: #if BITS_PER_WORD==32
75: typedef int word_type __attribute__ ((mode (SI)));
76: #endif
77: #if BITS_PER_WORD==64
78: typedef int word_type __attribute__ ((mode (DI)));
79: #endif
80:
81: /* Make sure that we don't accidentally use any normal C language built-in
82: type names in the first part of this file. Instead we want to use *only*
83: the type names defined above. The following macro definitions insure
84: that if we *do* accidentally use some normal C language built-in type name,
85: we will get a syntax error. */
86:
87: #define char bogus_type
88: #define short bogus_type
89: #define int bogus_type
90: #define long bogus_type
91: #define unsigned bogus_type
92: #define float bogus_type
93: #define double bogus_type
94:
95: #define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
96:
97: /* DIstructs are pairs of SItype values in the order determined by
98: WORDS_BIG_ENDIAN. */
99:
100: #if WORDS_BIG_ENDIAN
101: struct DIstruct {SItype high, low;};
102: #else
103: struct DIstruct {SItype low, high;};
104: #endif
105:
106: /* We need this union to unpack/pack DImode values, since we don't have
107: any arithmetic yet. Incoming DImode parameters are stored into the
108: `ll' field, and the unpacked result is read from the struct `s'. */
109:
110: typedef union
111: {
112: struct DIstruct s;
113: DItype ll;
114: } DIunion;
115:
116: #if defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)
117:
118: #include "longlong.h"
119:
120: #endif /* udiv or mul */
121:
122: extern DItype __fixunssfdi (SFtype a);
123: extern DItype __fixunsdfdi (DFtype a);
124: #if LONG_DOUBLE_TYPE_SIZE == 96
125: extern DItype __fixunsxfdi (XFtype a);
126: #endif
127: #if LONG_DOUBLE_TYPE_SIZE == 128
128: extern DItype __fixunstfdi (TFtype a);
129: #endif
130:
131: #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
132: #if defined (L_divdi3) || defined (L_moddi3)
133: static inline
134: #endif
135: DItype
136: __negdi2 (u)
137: DItype u;
138: {
139: DIunion w;
140: DIunion uu;
141:
142: uu.ll = u;
143:
144: w.s.low = -uu.s.low;
145: w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
146:
147: return w.ll;
148: }
149: #endif
150:
151: #ifdef L_lshldi3
152: DItype
153: __lshldi3 (u, b)
154: DItype u;
155: SItype b;
156: {
157: DIunion w;
158: SItype bm;
159: DIunion uu;
160:
161: if (b == 0)
162: return u;
163:
164: uu.ll = u;
165:
166: bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
167: if (bm <= 0)
168: {
169: w.s.low = 0;
170: w.s.high = (USItype)uu.s.low << -bm;
171: }
172: else
173: {
174: USItype carries = (USItype)uu.s.low >> bm;
175: w.s.low = (USItype)uu.s.low << b;
176: w.s.high = ((USItype)uu.s.high << b) | carries;
177: }
178:
179: return w.ll;
180: }
181: #endif
182:
183: #ifdef L_lshrdi3
184: DItype
185: __lshrdi3 (u, b)
186: DItype u;
187: SItype b;
188: {
189: DIunion w;
190: SItype bm;
191: DIunion uu;
192:
193: if (b == 0)
194: return u;
195:
196: uu.ll = u;
197:
198: bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
199: if (bm <= 0)
200: {
201: w.s.high = 0;
202: w.s.low = (USItype)uu.s.high >> -bm;
203: }
204: else
205: {
206: USItype carries = (USItype)uu.s.high << bm;
207: w.s.high = (USItype)uu.s.high >> b;
208: w.s.low = ((USItype)uu.s.low >> b) | carries;
209: }
210:
211: return w.ll;
212: }
213: #endif
214:
215: #ifdef L_ashldi3
216: DItype
217: __ashldi3 (u, b)
218: DItype u;
219: SItype b;
220: {
221: DIunion w;
222: SItype 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 (u, b)
250: DItype u;
251: SItype b;
252: {
253: DIunion w;
254: SItype bm;
255: DIunion uu;
256:
257: if (b == 0)
258: return u;
259:
260: uu.ll = u;
261:
262: bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
263: if (bm <= 0)
264: {
265: /* w.s.high = 1..1 or 0..0 */
266: w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
267: w.s.low = uu.s.high >> -bm;
268: }
269: else
270: {
271: USItype carries = (USItype)uu.s.high << bm;
272: w.s.high = uu.s.high >> b;
273: w.s.low = ((USItype)uu.s.low >> b) | carries;
274: }
275:
276: return w.ll;
277: }
278: #endif
279:
280: #ifdef L_ffsdi2
281: DItype
282: __ffsdi2 (u)
283: DItype u;
284: {
285: DIunion uu, w;
286: uu.ll = u;
287: w.s.high = 0;
288: w.s.low = ffs (uu.s.low);
289: if (w.s.low != 0)
290: return w.ll;
291: w.s.low = ffs (uu.s.high);
292: if (w.s.low != 0)
293: {
294: w.s.low += BITS_PER_UNIT * sizeof (SItype);
295: return w.ll;
296: }
297: return w.ll;
298: }
299: #endif
300:
301: #ifdef L_muldi3
302: DItype
303: __muldi3 (u, v)
304: DItype u, v;
305: {
306: DIunion w;
307: DIunion uu, vv;
308:
309: uu.ll = u,
310: vv.ll = v;
311:
312: w.ll = __umulsidi3 (uu.s.low, vv.s.low);
313: w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
314: + (USItype) uu.s.high * (USItype) vv.s.low);
315:
316: return w.ll;
317: }
318: #endif
319:
320: #ifdef L_udiv_w_sdiv
321: USItype
322: __udiv_w_sdiv (rp, a1, a0, d)
323: USItype *rp, a1, a0, d;
324: {
325: USItype q, r;
326: USItype c0, c1, b1;
327:
328: if ((SItype) d >= 0)
329: {
330: if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
331: {
332: /* dividend, divisor, and quotient are nonnegative */
333: sdiv_qrnnd (q, r, a1, a0, d);
334: }
335: else
336: {
337: /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
338: sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
339: /* Divide (c1*2^32 + c0) by d */
340: sdiv_qrnnd (q, r, c1, c0, d);
341: /* Add 2^31 to quotient */
342: q += (USItype) 1 << (SI_TYPE_SIZE - 1);
343: }
344: }
345: else
346: {
347: b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
348: c1 = a1 >> 1; /* A/2 */
349: c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
350:
351: if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
352: {
353: sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
354:
355: r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
356: if ((d & 1) != 0)
357: {
358: if (r >= q)
359: r = r - q;
360: else if (q - r <= d)
361: {
362: r = r - q + d;
363: q--;
364: }
365: else
366: {
367: r = r - q + 2*d;
368: q -= 2;
369: }
370: }
371: }
372: else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
373: {
374: c1 = (b1 - 1) - c1;
375: c0 = ~c0; /* logical NOT */
376:
377: sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
378:
379: q = ~q; /* (A/2)/b1 */
380: r = (b1 - 1) - r;
381:
382: r = 2*r + (a0 & 1); /* A/(2*b1) */
383:
384: if ((d & 1) != 0)
385: {
386: if (r >= q)
387: r = r - q;
388: else if (q - r <= d)
389: {
390: r = r - q + d;
391: q--;
392: }
393: else
394: {
395: r = r - q + 2*d;
396: q -= 2;
397: }
398: }
399: }
400: else /* Implies c1 = b1 */
401: { /* Hence a1 = d - 1 = 2*b1 - 1 */
402: if (a0 >= -d)
403: {
404: q = -1;
405: r = a0 + d;
406: }
407: else
408: {
409: q = -2;
410: r = a0 + 2*d;
411: }
412: }
413: }
414:
415: *rp = r;
416: return q;
417: }
418: #endif
419:
420: #ifdef L_udivmoddi4
421: static const UQItype __clz_tab[] =
422: {
423: 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,
424: 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,
425: 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,
426: 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,
427: 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,
428: 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,
429: 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,
430: 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,
431: };
432:
433: UDItype
434: __udivmoddi4 (n, d, rp)
435: UDItype n, d;
436: UDItype *rp;
437: {
438: DIunion ww;
439: DIunion nn, dd;
440: DIunion rr;
441: USItype d0, d1, n0, n1, n2;
442: USItype q0, q1;
443: USItype b, bm;
444:
445: nn.ll = n;
446: dd.ll = d;
447:
448: d0 = dd.s.low;
449: d1 = dd.s.high;
450: n0 = nn.s.low;
451: n1 = nn.s.high;
452:
453: #if !UDIV_NEEDS_NORMALIZATION
454: if (d1 == 0)
455: {
456: if (d0 > n1)
457: {
458: /* 0q = nn / 0D */
459:
460: udiv_qrnnd (q0, n0, n1, n0, d0);
461: q1 = 0;
462:
463: /* Remainder in n0. */
464: }
465: else
466: {
467: /* qq = NN / 0d */
468:
469: if (d0 == 0)
470: d0 = 1 / d0; /* Divide intentionally by zero. */
471:
472: udiv_qrnnd (q1, n1, 0, n1, d0);
473: udiv_qrnnd (q0, n0, n1, n0, d0);
474:
475: /* Remainder in n0. */
476: }
477:
478: if (rp != 0)
479: {
480: rr.s.low = n0;
481: rr.s.high = 0;
482: *rp = rr.ll;
483: }
484: }
485:
486: #else /* UDIV_NEEDS_NORMALIZATION */
487:
488: if (d1 == 0)
489: {
490: if (d0 > n1)
491: {
492: /* 0q = nn / 0D */
493:
494: count_leading_zeros (bm, d0);
495:
496: if (bm != 0)
497: {
498: /* Normalize, i.e. make the most significant bit of the
499: denominator set. */
500:
501: d0 = d0 << bm;
502: n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
503: n0 = n0 << bm;
504: }
505:
506: udiv_qrnnd (q0, n0, n1, n0, d0);
507: q1 = 0;
508:
509: /* Remainder in n0 >> bm. */
510: }
511: else
512: {
513: /* qq = NN / 0d */
514:
515: if (d0 == 0)
516: d0 = 1 / d0; /* Divide intentionally by zero. */
517:
518: count_leading_zeros (bm, d0);
519:
520: if (bm == 0)
521: {
522: /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
523: conclude (the most significant bit of n1 is set) /\ (the
524: leading quotient digit q1 = 1).
525:
526: This special case is necessary, not an optimization.
527: (Shifts counts of SI_TYPE_SIZE are undefined.) */
528:
529: n1 -= d0;
530: q1 = 1;
531: }
532: else
533: {
534: /* Normalize. */
535:
536: b = SI_TYPE_SIZE - bm;
537:
538: d0 = d0 << bm;
539: n2 = n1 >> b;
540: n1 = (n1 << bm) | (n0 >> b);
541: n0 = n0 << bm;
542:
543: udiv_qrnnd (q1, n1, n2, n1, d0);
544: }
545:
546: /* n1 != d0... */
547:
548: udiv_qrnnd (q0, n0, n1, n0, d0);
549:
550: /* Remainder in n0 >> bm. */
551: }
552:
553: if (rp != 0)
554: {
555: rr.s.low = n0 >> bm;
556: rr.s.high = 0;
557: *rp = rr.ll;
558: }
559: }
560: #endif /* UDIV_NEEDS_NORMALIZATION */
561:
562: else
563: {
564: if (d1 > n1)
565: {
566: /* 00 = nn / DD */
567:
568: q0 = 0;
569: q1 = 0;
570:
571: /* Remainder in n1n0. */
572: if (rp != 0)
573: {
574: rr.s.low = n0;
575: rr.s.high = n1;
576: *rp = rr.ll;
577: }
578: }
579: else
580: {
581: /* 0q = NN / dd */
582:
583: count_leading_zeros (bm, d1);
584: if (bm == 0)
585: {
586: /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
587: conclude (the most significant bit of n1 is set) /\ (the
588: quotient digit q0 = 0 or 1).
589:
590: This special case is necessary, not an optimization. */
591:
592: /* The condition on the next line takes advantage of that
593: n1 >= d1 (true due to program flow). */
594: if (n1 > d1 || n0 >= d0)
595: {
596: q0 = 1;
597: sub_ddmmss (n1, n0, n1, n0, d1, d0);
598: }
599: else
600: q0 = 0;
601:
602: q1 = 0;
603:
604: if (rp != 0)
605: {
606: rr.s.low = n0;
607: rr.s.high = n1;
608: *rp = rr.ll;
609: }
610: }
611: else
612: {
613: USItype m1, m0;
614: /* Normalize. */
615:
616: b = SI_TYPE_SIZE - bm;
617:
618: d1 = (d1 << bm) | (d0 >> b);
619: d0 = d0 << bm;
620: n2 = n1 >> b;
621: n1 = (n1 << bm) | (n0 >> b);
622: n0 = n0 << bm;
623:
624: udiv_qrnnd (q0, n1, n2, n1, d1);
625: umul_ppmm (m1, m0, q0, d0);
626:
627: if (m1 > n1 || (m1 == n1 && m0 > n0))
628: {
629: q0--;
630: sub_ddmmss (m1, m0, m1, m0, d1, d0);
631: }
632:
633: q1 = 0;
634:
635: /* Remainder in (n1n0 - m1m0) >> bm. */
636: if (rp != 0)
637: {
638: sub_ddmmss (n1, n0, n1, n0, m1, m0);
639: rr.s.low = (n1 << b) | (n0 >> bm);
640: rr.s.high = n1 >> bm;
641: *rp = rr.ll;
642: }
643: }
644: }
645: }
646:
647: ww.s.low = q0;
648: ww.s.high = q1;
649: return ww.ll;
650: }
651: #endif
652:
653: #ifdef L_divdi3
654: UDItype __udivmoddi4 ();
655:
656: DItype
657: __divdi3 (u, v)
658: DItype u, v;
659: {
660: SItype c = 0;
661: DIunion uu, vv;
662: DItype w;
663:
664: uu.ll = u;
665: vv.ll = v;
666:
667: if (uu.s.high < 0)
668: c = ~c,
669: uu.ll = __negdi2 (uu.ll);
670: if (vv.s.high < 0)
671: c = ~c,
672: vv.ll = __negdi2 (vv.ll);
673:
674: w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
675: if (c)
676: w = __negdi2 (w);
677:
678: return w;
679: }
680: #endif
681:
682: #ifdef L_moddi3
683: UDItype __udivmoddi4 ();
684: DItype
685: __moddi3 (u, v)
686: DItype u, v;
687: {
688: SItype c = 0;
689: DIunion uu, vv;
690: DItype w;
691:
692: uu.ll = u;
693: vv.ll = v;
694:
695: if (uu.s.high < 0)
696: c = ~c,
697: uu.ll = __negdi2 (uu.ll);
698: if (vv.s.high < 0)
699: vv.ll = __negdi2 (vv.ll);
700:
701: (void) __udivmoddi4 (uu.ll, vv.ll, &w);
702: if (c)
703: w = __negdi2 (w);
704:
705: return w;
706: }
707: #endif
708:
709: #ifdef L_umoddi3
710: UDItype __udivmoddi4 ();
711: UDItype
712: __umoddi3 (u, v)
713: UDItype u, v;
714: {
715: DItype w;
716:
717: (void) __udivmoddi4 (u, v, &w);
718:
719: return w;
720: }
721: #endif
722:
723: #ifdef L_udivdi3
724: UDItype __udivmoddi4 ();
725: UDItype
726: __udivdi3 (n, d)
727: UDItype n, d;
728: {
729: return __udivmoddi4 (n, d, (UDItype *) 0);
730: }
731: #endif
732:
733: #ifdef L_cmpdi2
734: word_type
735: __cmpdi2 (a, b)
736: DItype a, b;
737: {
738: DIunion au, bu;
739:
740: au.ll = a, bu.ll = b;
741:
742: if (au.s.high < bu.s.high)
743: return 0;
744: else if (au.s.high > bu.s.high)
745: return 2;
746: if ((USItype) au.s.low < (USItype) bu.s.low)
747: return 0;
748: else if ((USItype) au.s.low > (USItype) bu.s.low)
749: return 2;
750: return 1;
751: }
752: #endif
753:
754: #ifdef L_ucmpdi2
755: word_type
756: __ucmpdi2 (a, b)
757: DItype a, b;
758: {
759: DIunion au, bu;
760:
761: au.ll = a, bu.ll = b;
762:
763: if ((USItype) au.s.high < (USItype) bu.s.high)
764: return 0;
765: else if ((USItype) au.s.high > (USItype) bu.s.high)
766: return 2;
767: if ((USItype) au.s.low < (USItype) bu.s.low)
768: return 0;
769: else if ((USItype) au.s.low > (USItype) bu.s.low)
770: return 2;
771: return 1;
772: }
773: #endif
774:
775: #if defined(L_fixunstfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
776: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
777: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
778:
779: DItype
780: __fixunstfdi (a)
781: TFtype a;
782: {
783: TFtype b;
784: UDItype v;
785:
786: if (a < 0)
787: return 0;
788:
789: /* Compute high word of result, as a flonum. */
790: b = (a / HIGH_WORD_COEFF);
791: /* Convert that to fixed (but not to DItype!),
792: and shift it into the high word. */
793: v = (USItype) b;
794: v <<= WORD_SIZE;
795: /* Remove high part from the TFtype, leaving the low part as flonum. */
796: a -= (TFtype)v;
797: /* Convert that to fixed (but not to DItype!) and add it in.
798: Sometimes A comes out negative. This is significant, since
799: A has more bits than a long int does. */
800: if (a < 0)
801: v -= (USItype) (- a);
802: else
803: v += (USItype) a;
804: return v;
805: }
806: #endif
807:
808: #if defined(L_fixtfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
809: DItype
810: __fixtfdi (a)
811: TFtype a;
812: {
813: if (a < 0)
814: return - __fixunstfdi (-a);
815: return __fixunstfdi (a);
816: }
817: #endif
818:
819: #if defined(L_fixunsxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
820: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
821: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
822:
823: DItype
824: __fixunsxfdi (a)
825: XFtype a;
826: {
827: XFtype b;
828: UDItype v;
829:
830: if (a < 0)
831: return 0;
832:
833: /* Compute high word of result, as a flonum. */
834: b = (a / HIGH_WORD_COEFF);
835: /* Convert that to fixed (but not to DItype!),
836: and shift it into the high word. */
837: v = (USItype) b;
838: v <<= WORD_SIZE;
839: /* Remove high part from the XFtype, leaving the low part as flonum. */
840: a -= (XFtype)v;
841: /* Convert that to fixed (but not to DItype!) and add it in.
842: Sometimes A comes out negative. This is significant, since
843: A has more bits than a long int does. */
844: if (a < 0)
845: v -= (USItype) (- a);
846: else
847: v += (USItype) a;
848: return v;
849: }
850: #endif
851:
852: #if defined(L_fixxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
853: DItype
854: __fixxfdi (a)
855: XFtype a;
856: {
857: if (a < 0)
858: return - __fixunsxfdi (-a);
859: return __fixunsxfdi (a);
860: }
861: #endif
862:
863: #ifdef L_fixunsdfdi
864: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
865: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
866:
867: DItype
868: __fixunsdfdi (a)
869: DFtype a;
870: {
871: DFtype b;
872: UDItype v;
873:
874: if (a < 0)
875: return 0;
876:
877: /* Compute high word of result, as a flonum. */
878: b = (a / HIGH_WORD_COEFF);
879: /* Convert that to fixed (but not to DItype!),
880: and shift it into the high word. */
881: v = (USItype) b;
882: v <<= WORD_SIZE;
883: /* Remove high part from the DFtype, leaving the low part as flonum. */
884: a -= (DFtype)v;
885: /* Convert that to fixed (but not to DItype!) and add it in.
886: Sometimes A comes out negative. This is significant, since
887: A has more bits than a long int does. */
888: if (a < 0)
889: v -= (USItype) (- a);
890: else
891: v += (USItype) a;
892: return v;
893: }
894: #endif
895:
896: #ifdef L_fixdfdi
897: DItype
898: __fixdfdi (a)
899: DFtype a;
900: {
901: if (a < 0)
902: return - __fixunsdfdi (-a);
903: return __fixunsdfdi (a);
904: }
905: #endif
906:
907: #ifdef L_fixunssfdi
908: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
909: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
910:
911: DItype
912: __fixunssfdi (SFtype original_a)
913: {
914: /* Convert the SFtype to a DFtype, because that is surely not going
915: to lose any bits. Some day someone else can write a faster version
916: that avoids converting to DFtype, and verify it really works right. */
917: DFtype a = original_a;
918: DFtype b;
919: UDItype v;
920:
921: if (a < 0)
922: return 0;
923:
924: /* Compute high word of result, as a flonum. */
925: b = (a / HIGH_WORD_COEFF);
926: /* Convert that to fixed (but not to DItype!),
927: and shift it into the high word. */
928: v = (USItype) b;
929: v <<= WORD_SIZE;
930: /* Remove high part from the DFtype, leaving the low part as flonum. */
931: a -= (DFtype)v;
932: /* Convert that to fixed (but not to DItype!) and add it in.
933: Sometimes A comes out negative. This is significant, since
934: A has more bits than a long int does. */
935: if (a < 0)
936: v -= (USItype) (- a);
937: else
938: v += (USItype) a;
939: return v;
940: }
941: #endif
942:
943: #ifdef L_fixsfdi
944: DItype
945: __fixsfdi (SFtype a)
946: {
947: if (a < 0)
948: return - __fixunssfdi (-a);
949: return __fixunssfdi (a);
950: }
951: #endif
952:
953: #if defined(L_floatdixf) && (LONG_DOUBLE_TYPE_SIZE == 96)
954: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
955: #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
956: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
957:
958: XFtype
959: __floatdixf (u)
960: DItype u;
961: {
962: XFtype d;
963: SItype negate = 0;
964:
965: if (u < 0)
966: u = -u, negate = 1;
967:
968: d = (USItype) (u >> WORD_SIZE);
969: d *= HIGH_HALFWORD_COEFF;
970: d *= HIGH_HALFWORD_COEFF;
971: d += (USItype) (u & (HIGH_WORD_COEFF - 1));
972:
973: return (negate ? -d : d);
974: }
975: #endif
976:
977: #if defined(L_floatditf) && (LONG_DOUBLE_TYPE_SIZE == 128)
978: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
979: #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
980: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
981:
982: TFtype
983: __floatditf (u)
984: DItype u;
985: {
986: TFtype d;
987: SItype negate = 0;
988:
989: if (u < 0)
990: u = -u, negate = 1;
991:
992: d = (USItype) (u >> WORD_SIZE);
993: d *= HIGH_HALFWORD_COEFF;
994: d *= HIGH_HALFWORD_COEFF;
995: d += (USItype) (u & (HIGH_WORD_COEFF - 1));
996:
997: return (negate ? -d : d);
998: }
999: #endif
1000:
1001: #ifdef L_floatdidf
1002: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
1003: #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
1004: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1005:
1006: DFtype
1007: __floatdidf (u)
1008: DItype u;
1009: {
1010: DFtype d;
1011: SItype negate = 0;
1012:
1013: if (u < 0)
1014: u = -u, negate = 1;
1015:
1016: d = (USItype) (u >> WORD_SIZE);
1017: d *= HIGH_HALFWORD_COEFF;
1018: d *= HIGH_HALFWORD_COEFF;
1019: d += (USItype) (u & (HIGH_WORD_COEFF - 1));
1020:
1021: return (negate ? -d : d);
1022: }
1023: #endif
1024:
1025: #ifdef L_floatdisf
1026: #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
1027: #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
1028: #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1029:
1030: SFtype
1031: __floatdisf (u)
1032: DItype u;
1033: {
1034: /* Do the calculation in DFmode
1035: so that we don't lose any of the precision of the high word
1036: while multiplying it. */
1037: DFtype f;
1038: SItype negate = 0;
1039:
1040: if (u < 0)
1041: u = -u, negate = 1;
1042:
1043: f = (USItype) (u >> WORD_SIZE);
1044: f *= HIGH_HALFWORD_COEFF;
1045: f *= HIGH_HALFWORD_COEFF;
1046: f += (USItype) (u & (HIGH_WORD_COEFF - 1));
1047:
1048: return (SFtype) (negate ? -f : f);
1049: }
1050: #endif
1051:
1052: #if defined(L_fixunsxfsi) && LONG_DOUBLE_TYPE_SIZE == 96
1053: #include "glimits.h"
1054:
1055: USItype
1056: __fixunsxfsi (a)
1057: XFtype a;
1058: {
1059: if (a >= - (DFtype) LONG_MIN)
1060: return (SItype) (a + LONG_MIN) - LONG_MIN;
1061: return (SItype) a;
1062: }
1063: #endif
1064:
1065: #ifdef L_fixunsdfsi
1066: #include "glimits.h"
1067:
1068: USItype
1069: __fixunsdfsi (a)
1070: DFtype a;
1071: {
1072: if (a >= - (DFtype) LONG_MIN)
1073: return (SItype) (a + LONG_MIN) - LONG_MIN;
1074: return (SItype) a;
1075: }
1076: #endif
1077:
1078: #ifdef L_fixunssfsi
1079: #include "glimits.h"
1080:
1081: USItype
1082: __fixunssfsi (SFtype a)
1083: {
1084: if (a >= - (SFtype) LONG_MIN)
1085: return (SItype) (a + LONG_MIN) - LONG_MIN;
1086: return (SItype) a;
1087: }
1088: #endif
1089:
1090: /* From here on down, the routines use normal data types. */
1091:
1092: #define SItype bogus_type
1093: #define USItype bogus_type
1094: #define DItype bogus_type
1095: #define UDItype bogus_type
1096: #define SFtype bogus_type
1097: #define DFtype bogus_type
1098:
1099: #undef char
1100: #undef short
1101: #undef int
1102: #undef long
1103: #undef unsigned
1104: #undef float
1105: #undef double
1106:
1107: #ifdef L__gcc_bcmp
1108:
1109: /* Like bcmp except the sign is meaningful.
1110: Reult is negative if S1 is less than S2,
1111: positive if S1 is greater, 0 if S1 and S2 are equal. */
1112:
1113: int
1114: __gcc_bcmp (s1, s2, size)
1115: unsigned char *s1, *s2;
1116: size_t size;
1117: {
1118: while (size > 0)
1119: {
1120: unsigned char c1 = *s1++, c2 = *s2++;
1121: if (c1 != c2)
1122: return c1 - c2;
1123: size--;
1124: }
1125: return 0;
1126: }
1127:
1128: #endif
1129:
1130: #ifdef L_varargs
1131: #ifdef __i860__
1132: #if defined(__svr4__) || defined(__alliant__)
1133: asm (" .text");
1134: asm (" .align 4");
1135:
1136: /* The Alliant needs the added underscore. */
1137: asm (".globl __builtin_saveregs");
1138: asm ("__builtin_saveregs:");
1139: asm (".globl ___builtin_saveregs");
1140: asm ("___builtin_saveregs:");
1141:
1142: asm (" andnot 0x0f,%sp,%sp"); /* round down to 16-byte boundary */
1143: asm (" adds -96,%sp,%sp"); /* allocate stack space for reg save
1144: area and also for a new va_list
1145: structure */
1146: /* Save all argument registers in the arg reg save area. The
1147: arg reg save area must have the following layout (according
1148: to the svr4 ABI):
1149:
1150: struct {
1151: union {
1152: float freg[8];
1153: double dreg[4];
1154: } float_regs;
1155: long ireg[12];
1156: };
1157: */
1158:
1159: asm (" fst.q %f8, 0(%sp)"); /* save floating regs (f8-f15) */
1160: asm (" fst.q %f12,16(%sp)");
1161:
1162: asm (" st.l %r16,32(%sp)"); /* save integer regs (r16-r27) */
1163: asm (" st.l %r17,36(%sp)");
1164: asm (" st.l %r18,40(%sp)");
1165: asm (" st.l %r19,44(%sp)");
1166: asm (" st.l %r20,48(%sp)");
1167: asm (" st.l %r21,52(%sp)");
1168: asm (" st.l %r22,56(%sp)");
1169: asm (" st.l %r23,60(%sp)");
1170: asm (" st.l %r24,64(%sp)");
1171: asm (" st.l %r25,68(%sp)");
1172: asm (" st.l %r26,72(%sp)");
1173: asm (" st.l %r27,76(%sp)");
1174:
1175: asm (" adds 80,%sp,%r16"); /* compute the address of the new
1176: va_list structure. Put in into
1177: r16 so that it will be returned
1178: to the caller. */
1179:
1180: /* Initialize all fields of the new va_list structure. This
1181: structure looks like:
1182:
1183: typedef struct {
1184: unsigned long ireg_used;
1185: unsigned long freg_used;
1186: long *reg_base;
1187: long *mem_ptr;
1188: } va_list;
1189: */
1190:
1191: asm (" st.l %r0, 0(%r16)"); /* nfixed */
1192: asm (" st.l %r0, 4(%r16)"); /* nfloating */
1193: asm (" st.l %sp, 8(%r16)"); /* __va_ctl points to __va_struct. */
1194: asm (" bri %r1"); /* delayed return */
1195: asm (" st.l %r28,12(%r16)"); /* pointer to overflow args */
1196:
1197: #else /* not __svr4__ */
1198: #if defined(__PARAGON__)
1199: /*
1200: * we'll use SVR4-ish varargs but need SVR3.2 assembler syntax,
1201: * and we stand a better chance of hooking into libraries
1202: * compiled by PGI. [[email protected]]
1203: */
1204: asm (" .text");
1205: asm (" .align 4");
1206: asm (".globl __builtin_saveregs");
1207: asm ("__builtin_saveregs:");
1208: asm (".globl ___builtin_saveregs");
1209: asm ("___builtin_saveregs:");
1210:
1211: asm (" andnot 0x0f,sp,sp"); /* round down to 16-byte boundary */
1212: asm (" adds -96,sp,sp"); /* allocate stack space for reg save
1213: area and also for a new va_list
1214: structure */
1215: /* Save all argument registers in the arg reg save area. The
1216: arg reg save area must have the following layout (according
1217: to the svr4 ABI):
1218:
1219: struct {
1220: union {
1221: float freg[8];
1222: double dreg[4];
1223: } float_regs;
1224: long ireg[12];
1225: };
1226: */
1227:
1228: asm (" fst.q f8, 0(sp)");
1229: asm (" fst.q f12,16(sp)");
1230: asm (" st.l r16,32(sp)");
1231: asm (" st.l r17,36(sp)");
1232: asm (" st.l r18,40(sp)");
1233: asm (" st.l r19,44(sp)");
1234: asm (" st.l r20,48(sp)");
1235: asm (" st.l r21,52(sp)");
1236: asm (" st.l r22,56(sp)");
1237: asm (" st.l r23,60(sp)");
1238: asm (" st.l r24,64(sp)");
1239: asm (" st.l r25,68(sp)");
1240: asm (" st.l r26,72(sp)");
1241: asm (" st.l r27,76(sp)");
1242:
1243: asm (" adds 80,sp,r16"); /* compute the address of the new
1244: va_list structure. Put in into
1245: r16 so that it will be returned
1246: to the caller. */
1247:
1248: /* Initialize all fields of the new va_list structure. This
1249: structure looks like:
1250:
1251: typedef struct {
1252: unsigned long ireg_used;
1253: unsigned long freg_used;
1254: long *reg_base;
1255: long *mem_ptr;
1256: } va_list;
1257: */
1258:
1259: asm (" st.l r0, 0(r16)"); /* nfixed */
1260: asm (" st.l r0, 4(r16)"); /* nfloating */
1261: asm (" st.l sp, 8(r16)"); /* __va_ctl points to __va_struct. */
1262: asm (" bri r1"); /* delayed return */
1263: asm (" st.l r28,12(r16)"); /* pointer to overflow args */
1264: #else /* not __PARAGON__ */
1265: asm (" .text");
1266: asm (" .align 4");
1267:
1268: asm (".globl ___builtin_saveregs");
1269: asm ("___builtin_saveregs:");
1270: asm (" mov sp,r30");
1271: asm (" andnot 0x0f,sp,sp");
1272: asm (" adds -96,sp,sp"); /* allocate sufficient space on the stack */
1273:
1274: /* Fill in the __va_struct. */
1275: asm (" st.l r16, 0(sp)"); /* save integer regs (r16-r27) */
1276: asm (" st.l r17, 4(sp)"); /* int fixed[12] */
1277: asm (" st.l r18, 8(sp)");
1278: asm (" st.l r19,12(sp)");
1279: asm (" st.l r20,16(sp)");
1280: asm (" st.l r21,20(sp)");
1281: asm (" st.l r22,24(sp)");
1282: asm (" st.l r23,28(sp)");
1283: asm (" st.l r24,32(sp)");
1284: asm (" st.l r25,36(sp)");
1285: asm (" st.l r26,40(sp)");
1286: asm (" st.l r27,44(sp)");
1287:
1288: asm (" fst.q f8, 48(sp)"); /* save floating regs (f8-f15) */
1289: asm (" fst.q f12,64(sp)"); /* int floating[8] */
1290:
1291: /* Fill in the __va_ctl. */
1292: asm (" st.l sp, 80(sp)"); /* __va_ctl points to __va_struct. */
1293: asm (" st.l r28,84(sp)"); /* pointer to more args */
1294: asm (" st.l r0, 88(sp)"); /* nfixed */
1295: asm (" st.l r0, 92(sp)"); /* nfloating */
1296:
1297: asm (" adds 80,sp,r16"); /* return address of the __va_ctl. */
1298: asm (" bri r1");
1299: asm (" mov r30,sp");
1300: /* recover stack and pass address to start
1301: of data. */
1302: #endif /* not __PARAGON__ */
1303: #endif /* not __svr4__ */
1304: #else /* not __i860__ */
1305: #ifdef __sparc__
1306: asm (".global __builtin_saveregs");
1307: asm ("__builtin_saveregs:");
1308: asm (".global ___builtin_saveregs");
1309: asm ("___builtin_saveregs:");
1310: #ifdef NEED_PROC_COMMAND
1311: asm (".proc 020");
1312: #endif
1313: asm ("st %i0,[%fp+68]");
1314: asm ("st %i1,[%fp+72]");
1315: asm ("st %i2,[%fp+76]");
1316: asm ("st %i3,[%fp+80]");
1317: asm ("st %i4,[%fp+84]");
1318: asm ("retl");
1319: asm ("st %i5,[%fp+88]");
1320: #ifdef NEED_TYPE_COMMAND
1321: asm (".type __builtin_saveregs,#function");
1322: asm (".size __builtin_saveregs,.-__builtin_saveregs");
1323: #endif
1324: #else /* not __sparc__ */
1325: #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
1326:
1327: asm (" .text");
1328: asm (" .ent __builtin_saveregs");
1329: asm (" .globl __builtin_saveregs");
1330: asm ("__builtin_saveregs:");
1331: asm (" sw $4,0($30)");
1332: asm (" sw $5,4($30)");
1333: asm (" sw $6,8($30)");
1334: asm (" sw $7,12($30)");
1335: asm (" j $31");
1336: asm (" .end __builtin_saveregs");
1337: #else /* not __mips__, etc. */
1338: __builtin_saveregs ()
1339: {
1340: abort ();
1341: }
1342: #endif /* not __mips__ */
1343: #endif /* not __sparc__ */
1344: #endif /* not __i860__ */
1345: #endif
1346:
1347: #ifdef L_eprintf
1348: #ifndef inhibit_libc
1349:
1350: #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1351: #include <stdio.h>
1352: /* This is used by the `assert' macro. */
1353: void
1354: __eprintf (string, expression, line, filename)
1355: const char *string;
1356: const char *expression;
1357: int line;
1358: const char *filename;
1359: {
1360: fprintf (stderr, string, expression, line, filename);
1361: fflush (stderr);
1362: abort ();
1363: }
1364:
1365: #endif
1366: #endif
1367:
1368: #ifdef L_bb
1369:
1370: /* Structure emitted by -a */
1371: struct bb
1372: {
1373: long zero_word;
1374: const char *filename;
1375: long *counts;
1376: long ncounts;
1377: struct bb *next;
1378: const unsigned long *addresses;
1379:
1380: /* Older GCC's did not emit these fields. */
1381: long nwords;
1382: const char **functions;
1383: const long *line_nums;
1384: const char **filenames;
1385: };
1386:
1387: #ifdef BLOCK_PROFILER_CODE
1388: BLOCK_PROFILER_CODE
1389: #else
1390: #ifndef inhibit_libc
1391:
1392: /* Simple minded basic block profiling output dumper for
1393: systems that don't provde tcov support. At present,
1394: it requires atexit and stdio. */
1395:
1396: #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1397: #include <stdio.h>
1398:
1399: #ifdef HAVE_ATEXIT
1400: extern void atexit (void (*) (void));
1401: #define ON_EXIT(FUNC,ARG) atexit ((FUNC))
1402: #else
1403: #ifdef sun
1404: extern void on_exit (void*, void*);
1405: #define ON_EXIT(FUNC,ARG) on_exit ((FUNC), (ARG))
1406: #endif
1407: #endif
1408:
1409: static struct bb *bb_head = (struct bb *)0;
1410:
1411: /* Return the number of digits needed to print a value */
1412: /* __inline__ */ static int num_digits (long value, int base)
1413: {
1414: int minus = (value < 0 && base != 16);
1415: unsigned long v = (minus) ? -value : value;
1416: int ret = minus;
1417:
1418: do
1419: {
1420: v /= base;
1421: ret++;
1422: }
1423: while (v);
1424:
1425: return ret;
1426: }
1427:
1428: void
1429: __bb_exit_func (void)
1430: {
1431: FILE *file = fopen ("bb.out", "a");
1432: long time_value;
1433:
1434: if (!file)
1435: perror ("bb.out");
1436:
1437: else
1438: {
1439: struct bb *ptr;
1440:
1441: /* This is somewhat type incorrect, but it avoids worrying about
1442: exactly where time.h is included from. It should be ok unless
1443: a void * differs from other pointer formats, or if sizeof(long)
1444: is < sizeof (time_t). It would be nice if we could assume the
1445: use of rationale standards here. */
1446:
1447: time((void *) &time_value);
1448: fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
1449:
1450: /* We check the length field explicitly in order to allow compatibility
1451: with older GCC's which did not provide it. */
1452:
1453: for (ptr = bb_head; ptr != (struct bb *)0; ptr = ptr->next)
1454: {
1455: int i;
1456: int func_p = (ptr->nwords >= sizeof (struct bb) && ptr->nwords <= 1000);
1457: int line_p = (func_p && ptr->line_nums);
1458: int file_p = (func_p && ptr->filenames);
1459: long ncounts = ptr->ncounts;
1460: long cnt_max = 0;
1461: long line_max = 0;
1462: long addr_max = 0;
1463: int file_len = 0;
1464: int func_len = 0;
1465: int blk_len = num_digits (ncounts, 10);
1466: int cnt_len;
1467: int line_len;
1468: int addr_len;
1469:
1470: fprintf (file, "File %s, %ld basic blocks \n\n",
1471: ptr->filename, ncounts);
1472:
1473: /* Get max values for each field. */
1474: for (i = 0; i < ncounts; i++)
1475: {
1476: const char *p;
1477: int len;
1478:
1479: if (cnt_max < ptr->counts[i])
1480: cnt_max = ptr->counts[i];
1481:
1482: if (addr_max < ptr->addresses[i])
1483: addr_max = ptr->addresses[i];
1484:
1485: if (line_p && line_max < ptr->line_nums[i])
1486: line_max = ptr->line_nums[i];
1487:
1488: if (func_p)
1489: {
1490: p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
1491: len = strlen (p);
1492: if (func_len < len)
1493: func_len = len;
1494: }
1495:
1496: if (file_p)
1497: {
1498: p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
1499: len = strlen (p);
1500: if (file_len < len)
1501: file_len = len;
1502: }
1503: }
1504:
1505: addr_len = num_digits (addr_max, 16);
1506: cnt_len = num_digits (cnt_max, 10);
1507: line_len = num_digits (line_max, 10);
1508:
1509: /* Now print out the basic block information. */
1510: for (i = 0; i < ncounts; i++)
1511: {
1512: fprintf (file,
1513: " Block #%*d: executed %*ld time(s) address= 0x%.*lx",
1514: blk_len, i+1,
1515: cnt_len, ptr->counts[i],
1516: addr_len, ptr->addresses[i]);
1517:
1518: if (func_p)
1519: fprintf (file, " function= %-*s", func_len,
1520: (ptr->functions[i]) ? ptr->functions[i] : "<none>");
1521:
1522: if (line_p)
1523: fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
1524:
1525: if (file_p)
1526: fprintf (file, " file= %s",
1527: (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
1528:
1529: fprintf (file, "\n");
1530: }
1531:
1532: fprintf (file, "\n");
1533: fflush (file);
1534: }
1535:
1536: fprintf (file, "\n\n");
1537: fclose (file);
1538: }
1539: }
1540:
1541: void
1542: __bb_init_func (struct bb *blocks)
1543: {
1544: /* User is supposed to check whether the first word is non-0,
1545: but just in case.... */
1546:
1547: if (blocks->zero_word)
1548: return;
1549:
1550: #ifdef ON_EXIT
1551: /* Initialize destructor. */
1552: if (!bb_head)
1553: ON_EXIT (__bb_exit_func, 0);
1554: #endif
1555:
1556: /* Set up linked list. */
1557: blocks->zero_word = 1;
1558: blocks->next = bb_head;
1559: bb_head = blocks;
1560: }
1561:
1562: #endif /* not inhibit_libc */
1563: #endif /* not BLOCK_PROFILER_CODE */
1564: #endif /* L_bb */
1565:
1566: /* frills for C++ */
1567:
1568: #ifdef L_op_new
1569: typedef void (*vfp)(void);
1570:
1571: #ifdef NEXT_SEMANTICS
1572: extern vfp __get_new_handler ();
1573: #else
1574: extern vfp __new_handler;
1575: #endif
1576:
1577: /* void * operator new (size_t sz) */
1578: void *
1579: __builtin_new (size_t sz)
1580: {
1581: void *p;
1582:
1583: /* malloc (0) is unpredictable; avoid it. */
1584: if (sz == 0)
1585: sz = 1;
1586: p = (void *) malloc (sz);
1587: if (p == 0)
1588: #ifdef NEXT_SEMANTICS
1589: (*__get_new_handler ()) ();
1590: #else
1591: (*__new_handler) ();
1592: #endif
1593: return p;
1594: }
1595: #endif /* L_op_new */
1596:
1597: #ifdef L_new_handler
1598:
1599: #ifndef inhibit_libc
1600: /* This gets us __GNU_LIBRARY__. */
1601: #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1602: #include <stdio.h>
1603:
1604: #ifdef __GNU_LIBRARY__
1605: /* Avoid forcing the library's meaning of `write' on the user program
1606: by using the "internal" name (for use within the library) */
1607: #define write(fd, buf, n) __write((fd), (buf), (n))
1608: #endif
1609: #endif /* inhibit_libc */
1610:
1611: typedef void (*vfp)(void);
1612:
1613: extern void *__builtin_new (size_t);
1614: static void default_new_handler (void);
1615:
1616: #ifdef NEXT_SEMANTICS
1617: static
1618: #endif
1619: vfp __new_handler = default_new_handler;
1620:
1621: #ifdef NEXT_SEMANTICS
1622: vfp
1623: __get_new_handler ()
1624: {
1625: return __new_handler;
1626: }
1627: #endif
1628:
1629: vfp
1630: __set_new_handler (handler)
1631: vfp handler;
1632: {
1633: vfp prev_handler;
1634:
1635: prev_handler = __new_handler;
1636: if (handler == 0) handler = default_new_handler;
1637: __new_handler = handler;
1638: return prev_handler;
1639: }
1640:
1641: vfp
1642: set_new_handler (handler)
1643: vfp handler;
1644: {
1645: return __set_new_handler (handler);
1646: }
1647:
1648: #define MESSAGE "Virtual memory exceeded in `new'\n"
1649:
1650: static void
1651: default_new_handler ()
1652: {
1653: /* don't use fprintf (stderr, ...) because it may need to call malloc. */
1654: /* This should really print the name of the program, but that is hard to
1655: do. We need a standard, clean way to get at the name. */
1656: write (2, MESSAGE, sizeof (MESSAGE));
1657: /* don't call exit () because that may call global destructors which
1658: may cause a loop. */
1659: _exit (-1);
1660: }
1661: #endif
1662:
1663: #ifdef L_op_delete
1664: /* void operator delete (void *ptr) */
1665: void
1666: __builtin_delete (void *ptr)
1667: {
1668: if (ptr)
1669: free (ptr);
1670: }
1671: #endif
1672:
1673: #ifdef L_shtab
1674: const unsigned int __shtab[] = {
1675: 0x00000001, 0x00000002, 0x00000004, 0x00000008,
1676: 0x00000010, 0x00000020, 0x00000040, 0x00000080,
1677: 0x00000100, 0x00000200, 0x00000400, 0x00000800,
1678: 0x00001000, 0x00002000, 0x00004000, 0x00008000,
1679: 0x00010000, 0x00020000, 0x00040000, 0x00080000,
1680: 0x00100000, 0x00200000, 0x00400000, 0x00800000,
1681: 0x01000000, 0x02000000, 0x04000000, 0x08000000,
1682: 0x10000000, 0x20000000, 0x40000000, 0x80000000
1683: };
1684: #endif
1685:
1686: #ifdef L_clear_cache
1687: /* Clear part of an instruction cache. */
1688:
1689: #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1690:
1691: void
1692: __clear_cache (beg, end)
1693: char *beg, *end;
1694: {
1695: #ifdef CLEAR_INSN_CACHE
1696: CLEAR_INSN_CACHE (beg, end);
1697: #else
1698: #ifdef INSN_CACHE_SIZE
1699: static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1700: static int initialized = 0;
1701: int offset;
1702: void *start_addr
1703: void *end_addr;
1704: typedef (*function_ptr) ();
1705:
1706: #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1707: /* It's cheaper to clear the whole cache.
1708: Put in a series of jump instructions so that calling the beginning
1709: of the cache will clear the whole thing. */
1710:
1711: if (! initialized)
1712: {
1713: int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1714: & -INSN_CACHE_LINE_WIDTH);
1715: int end_ptr = ptr + INSN_CACHE_SIZE;
1716:
1717: while (ptr < end_ptr)
1718: {
1719: *(INSTRUCTION_TYPE *)ptr
1720: = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1721: ptr += INSN_CACHE_LINE_WIDTH;
1722: }
1723: *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1724:
1725: initialized = 1;
1726: }
1727:
1728: /* Call the beginning of the sequence. */
1729: (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1730: & -INSN_CACHE_LINE_WIDTH))
1731: ());
1732:
1733: #else /* Cache is large. */
1734:
1735: if (! initialized)
1736: {
1737: int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1738: & -INSN_CACHE_LINE_WIDTH);
1739:
1740: while (ptr < (int) array + sizeof array)
1741: {
1742: *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1743: ptr += INSN_CACHE_LINE_WIDTH;
1744: }
1745:
1746: initialized = 1;
1747: }
1748:
1749: /* Find the location in array that occupies the same cache line as BEG. */
1750:
1751: offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1752: start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1753: & -INSN_CACHE_PLANE_SIZE)
1754: + offset);
1755:
1756: /* Compute the cache alignment of the place to stop clearing. */
1757: #if 0 /* This is not needed for gcc's purposes. */
1758: /* If the block to clear is bigger than a cache plane,
1759: we clear the entire cache, and OFFSET is already correct. */
1760: if (end < beg + INSN_CACHE_PLANE_SIZE)
1761: #endif
1762: offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1763: & -INSN_CACHE_LINE_WIDTH)
1764: & (INSN_CACHE_PLANE_SIZE - 1));
1765:
1766: #if INSN_CACHE_DEPTH > 1
1767: end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1768: if (end_addr <= start_addr)
1769: end_addr += INSN_CACHE_PLANE_SIZE;
1770:
1771: for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1772: {
1773: int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1774: int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1775:
1776: while (addr != stop)
1777: {
1778: /* Call the return instruction at ADDR. */
1779: ((function_ptr) addr) ();
1780:
1781: addr += INSN_CACHE_LINE_WIDTH;
1782: }
1783: }
1784: #else /* just one plane */
1785: do
1786: {
1787: /* Call the return instruction at START_ADDR. */
1788: ((function_ptr) start_addr) ();
1789:
1790: start_addr += INSN_CACHE_LINE_WIDTH;
1791: }
1792: while ((start_addr % INSN_CACHE_SIZE) != offset);
1793: #endif /* just one plane */
1794: #endif /* Cache is large */
1795: #endif /* Cache exists */
1796: #endif /* CLEAR_INSN_CACHE */
1797: }
1798:
1799: #endif /* L_clear_cache */
1800:
1801: #ifdef L_trampoline
1802:
1803: /* Jump to a trampoline, loading the static chain address. */
1804:
1805: #ifdef TRANSFER_FROM_TRAMPOLINE
1806: TRANSFER_FROM_TRAMPOLINE
1807: #endif
1808:
1809: #if defined (NeXT) && defined (__MACH__)
1810:
1811: /* Make stack executable so we can call trampolines on stack.
1812: This is called from INITIALIZE_TRAMPOLINE in next.h. */
1813:
1814: void
1815: __enable_execute_stack (addr)
1816: char *addr;
1817: {
1818: char *eaddr = addr + TRAMPOLINE_SIZE;
1819:
1820: #ifdef CLEAR_INSN_CACHE
1821: CLEAR_INSN_CACHE (addr, eaddr);
1822: #else
1823: __clear_cache ((int) addr, (int) eaddr);
1824: #endif
1825: }
1826:
1827: #endif /* defined (NeXT) && defined (__MACH__) */
1828:
1829: #ifdef __convex__
1830:
1831: /* Make stack executable so we can call trampolines on stack.
1832: This is called from INITIALIZE_TRAMPOLINE in convex.h. */
1833:
1834: #include <sys/mman.h>
1835: #include <sys/vmparam.h>
1836: #include <machine/machparam.h>
1837:
1838: void
1839: __enable_execute_stack ()
1840: {
1841: int fp;
1842: static unsigned lowest = USRSTACK;
1843: unsigned current = (unsigned) &fp & -NBPG;
1844:
1845: if (lowest > current)
1846: {
1847: unsigned len = lowest - current;
1848: mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1849: lowest = current;
1850: }
1851:
1852: /* Clear instruction cache in case an old trampoline is in it. */
1853: asm ("pich");
1854: }
1855: #endif /* __convex__ */
1856:
1857: #ifdef __DOLPHIN__
1858:
1859: /* Modified from the convex -code above. */
1860:
1861: #include <sys/param.h>
1862: #include <errno.h>
1863: #include <sys/m88kbcs.h>
1864:
1865: void
1866: __enable_execute_stack ()
1867: {
1868: int save_errno;
1869: static unsigned long lowest = USRSTACK;
1870: unsigned long current = (unsigned long) &save_errno & -NBPC;
1871:
1872: /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1873: address is seen as 'negative'. That is the case with the stack. */
1874:
1875: save_errno=errno;
1876: if (lowest > current)
1877: {
1878: unsigned len=lowest-current;
1879: memctl(current,len,MCT_TEXT);
1880: lowest = current;
1881: }
1882: else
1883: memctl(current,NBPC,MCT_TEXT);
1884: errno=save_errno;
1885: }
1886:
1887: #endif /* __DOLPHIN__ */
1888:
1889: #ifdef __pyr__
1890:
1891: #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1892: #include <stdio.h>
1893: #include <sys/mman.h>
1894: #include <sys/types.h>
1895: #include <sys/param.h>
1896: #include <sys/vmmac.h>
1897:
1898: /* Modified from the convex -code above.
1899: mremap promises to clear the i-cache. */
1900:
1901: void
1902: __enable_execute_stack ()
1903: {
1904: int fp;
1905: if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1906: PROT_READ|PROT_WRITE|PROT_EXEC))
1907: {
1908: perror ("mprotect in __enable_execute_stack");
1909: fflush (stderr);
1910: abort ();
1911: }
1912: }
1913: #endif /* __pyr__ */
1914: #endif /* L_trampoline */
1915:
1916: #ifdef L__main
1917:
1918: #include "gbl-ctors.h"
1919: /* Some systems use __main in a way incompatible with its use in gcc, in these
1920: cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1921: give the same symbol without quotes for an alternative entry point. You
1922: must define both, or niether. */
1923: #ifndef NAME__MAIN
1924: #define NAME__MAIN "__main"
1925: #define SYMBOL__MAIN __main
1926: #endif
1927:
1928: /* Run all the global destructors on exit from the program. */
1929:
1930: void
1931: __do_global_dtors ()
1932: {
1933: #ifdef DO_GLOBAL_DTORS_BODY
1934: DO_GLOBAL_DTORS_BODY;
1935: #else
1936: unsigned nptrs = (unsigned HOST_WIDE_INT) __DTOR_LIST__[0];
1937: unsigned i;
1938:
1939: /* Some systems place the number of pointers
1940: in the first word of the table.
1941: On other systems, that word is -1.
1942: In all cases, the table is null-terminated. */
1943:
1944: /* If the length is not recorded, count up to the null. */
1945: if (nptrs == -1)
1946: for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++);
1947:
1948: /* GNU LD format. */
1949: for (i = nptrs; i >= 1; i--)
1950: __DTOR_LIST__[i] ();
1951: #endif
1952: }
1953:
1954: #ifndef INIT_SECTION_ASM_OP
1955: /* Run all the global constructors on entry to the program. */
1956:
1957: #ifndef ON_EXIT
1958: #define ON_EXIT(a, b)
1959: #else
1960: /* Make sure the exit routine is pulled in to define the globals as
1961: bss symbols, just in case the linker does not automatically pull
1962: bss definitions from the library. */
1963:
1964: #ifndef NEXT_SEMANTICS
1965: extern int _exit_dummy_decl;
1966: int *_exit_dummy_ref = &_exit_dummy_decl;
1967: #endif
1968: #endif /* ON_EXIT */
1969:
1970: void
1971: __do_global_ctors ()
1972: {
1973: DO_GLOBAL_CTORS_BODY;
1974: ON_EXIT (__do_global_dtors, 0);
1975: }
1976: #endif /* no INIT_SECTION_ASM_OP */
1977:
1978: #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
1979: /* Subroutine called automatically by `main'.
1980: Compiling a global function named `main'
1981: produces an automatic call to this function at the beginning.
1982:
1983: For many systems, this routine calls __do_global_ctors.
1984: For systems which support a .init section we use the .init section
1985: to run __do_global_ctors, so we need not do anything here. */
1986:
1987: #ifdef NEXT_PDO
1988: /* do some hokey stuff to get automatic _objcInit to work */
1989: /* this data location is referenced in the NeXT_PDO runtime */
1990: /* so that we can do the magic rondevaux */
1991: int _objcInit_addr;
1992: #endif
1993:
1994: #ifdef NEXT_EXTENSION
1995: int __gnuc_argc;
1996: const char **__gnuc_argv;
1997: #endif
1998:
1999: void
2000: #ifdef NEXT_EXTENSION
2001: SYMBOL__MAIN (int argc, const char **argv)
2002: #else
2003: SYMBOL__MAIN ()
2004: #endif
2005: {
2006: /* Support recursive calls to `main': run initializers just once. */
2007: static int initialized = 0;
2008:
2009: #ifdef NEXT_EXTENSION
2010: __gnuc_argc = argc;
2011: __gnuc_argv = argv;
2012: #endif
2013:
2014: if (! initialized)
2015: {
2016: initialized = 1;
2017: __do_global_ctors ();
2018: #ifdef NEXT_PDO
2019: if (_objcInit_addr)
2020: ((void (*)())_objcInit_addr)();
2021: #endif
2022: }
2023: }
2024: #endif /* no INIT_SECTION_ASM_OP or INVOKE__main */
2025:
2026: #endif /* L__main */
2027:
2028: #ifdef L_ctors
2029:
2030: #include "gbl-ctors.h"
2031:
2032: /* Provide default definitions for the lists of constructors and
2033: destructors, so that we don't get linker errors. These symbols are
2034: intentionally bss symbols, so that gld and/or collect will provide
2035: the right values. */
2036:
2037: /* We declare the lists here with two elements each,
2038: so that they are valid empty lists if no other definition is loaded. */
2039: #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2040: #ifdef __NeXT__
2041: /* After 2.3, try this definition on all systems. */
2042: func_ptr __CTOR_LIST__[2] = {0, 0};
2043: func_ptr __DTOR_LIST__[2] = {0, 0};
2044: #else
2045: func_ptr __CTOR_LIST__[2];
2046: func_ptr __DTOR_LIST__[2];
2047: #endif
2048: #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2049: #endif /* L_ctors */
2050:
2051: #ifdef L_exit
2052:
2053: #include "gbl-ctors.h"
2054:
2055: #ifndef ON_EXIT
2056:
2057: /* If we have no known way of registering our own __do_global_dtors
2058: routine so that it will be invoked at program exit time, then we
2059: have to define our own exit routine which will get this to happen. */
2060:
2061: extern void __do_global_dtors ();
2062: extern void _cleanup ();
2063: extern void _exit () __attribute__ ((noreturn));
2064:
2065: void
2066: exit (status)
2067: int status;
2068: {
2069: __do_global_dtors ();
2070: #ifdef EXIT_BODY
2071: EXIT_BODY;
2072: #else
2073: _cleanup ();
2074: #endif
2075: _exit (status);
2076: }
2077:
2078: #else
2079: int _exit_dummy_decl = 0; /* prevent compiler & linker warnings */
2080: #endif
2081:
2082: #endif /* L_exit */
2083:
2084: /* In a.out systems, we need to have these dummy constructor and destructor
2085: lists in the library.
2086:
2087: When using `collect', the first link will resolve __CTOR_LIST__
2088: and __DTOR_LIST__ to these symbols. We will then run "nm" on the
2089: result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
2090: Since we don't do the second link if no constructors existed, these
2091: dummies must be fully functional empty lists.
2092:
2093: When using `gnu ld', these symbols will be used if there are no
2094: constructors. If there are constructors, the N_SETV symbol defined
2095: by the linker from the N_SETT's in input files will define __CTOR_LIST__
2096: and __DTOR_LIST__ rather than its being allocated as common storage
2097: by the definitions below.
2098:
2099: When using a linker that supports constructor and destructor segments,
2100: these definitions will not be used, since crtbegin.o and crtend.o
2101: (from crtstuff.c) will have already defined __CTOR_LIST__ and
2102: __DTOR_LIST__. The crt*.o files are passed directly to the linker
2103: on its command line, by gcc. */
2104:
2105: /* The list needs two elements: one is ignored (the old count); the
2106: second is the terminating zero. Since both values are zero, this
2107: declaration is not initialized, and it becomes `common'. */
2108:
2109: #ifdef L_ctor_list
2110: #include "gbl-ctors.h"
2111: func_ptr __CTOR_LIST__[2];
2112: #endif
2113:
2114: #ifdef L_dtor_list
2115: #include "gbl-ctors.h"
2116: func_ptr __DTOR_LIST__[2];
2117: #endif
2118:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.