![[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 [GCC 2.x] / gcc|
Return to libgcc2.c CVS log | Up to [GCC 2.x] / gcc |
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 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 "tm.h"
32: #include "gstddef.h"
33:
34: /* Don't use `fancy_abort' here even if config.h says to use it. */
35: #ifdef abort
36: #undef abort
37: #endif
38:
39: /* Need to undef this because LONG_TYPE_SIZE may rely upon GCC's
40: internal `target_flags' variable. */
41: #undef LONG_TYPE_SIZE
42:
43: #define LONG_TYPE_SIZE (sizeof (long) * BITS_PER_UNIT)
44:
45: #ifndef SItype
46: #define SItype long int
47: #endif
48:
49: /* long long ints are pairs of long ints in the order determined by
50: WORDS_BIG_ENDIAN. */
51:
52: #if WORDS_BIG_ENDIAN
53: struct longlong {long high, low;};
54: #else
55: struct longlong {long low, high;};
56: #endif
57:
58: /* We need this union to unpack/pack longlongs, since we don't have
59: any arithmetic yet. Incoming long long parameters are stored
60: into the `ll' field, and the unpacked result is read from the struct
61: longlong. */
62:
63: typedef union
64: {
65: struct longlong s;
66: long long ll;
67: } long_long;
68:
69: #if defined (L_udivmoddi4) || defined (L_muldi3)
70:
71: #include "longlong.h"
72:
73: #endif /* udiv or mul */
74:
75: extern long long __fixunssfdi (float a);
76: extern long long __fixunsdfdi (double a);
77:
78: #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
79: #if defined (L_divdi3) || defined (L_moddi3)
80: static inline
81: #endif
82: long long
83: __negdi2 (u)
84: long long u;
85: {
86: long_long w;
87: long_long uu;
88:
89: uu.ll = u;
90:
91: w.s.low = -uu.s.low;
92: w.s.high = -uu.s.high - ((unsigned long) w.s.low > 0);
93:
94: return w.ll;
95: }
96: #endif
97:
98: #ifdef L_lshldi3
99: long long
100: __lshldi3 (u, b)
101: long long u;
102: int b;
103: {
104: long_long w;
105: long bm;
106: long_long uu;
107:
108: if (b == 0)
109: return u;
110:
111: uu.ll = u;
112:
113: bm = (sizeof (long) * BITS_PER_UNIT) - b;
114: if (bm <= 0)
115: {
116: w.s.low = 0;
117: w.s.high = (unsigned long)uu.s.low << -bm;
118: }
119: else
120: {
121: unsigned long carries = (unsigned long)uu.s.low >> bm;
122: w.s.low = (unsigned long)uu.s.low << b;
123: w.s.high = ((unsigned long)uu.s.high << b) | carries;
124: }
125:
126: return w.ll;
127: }
128: #endif
129:
130: #ifdef L_lshrdi3
131: long long
132: __lshrdi3 (u, b)
133: long long u;
134: int b;
135: {
136: long_long w;
137: long bm;
138: long_long uu;
139:
140: if (b == 0)
141: return u;
142:
143: uu.ll = u;
144:
145: bm = (sizeof (long) * BITS_PER_UNIT) - b;
146: if (bm <= 0)
147: {
148: w.s.high = 0;
149: w.s.low = (unsigned long)uu.s.high >> -bm;
150: }
151: else
152: {
153: unsigned long carries = (unsigned long)uu.s.high << bm;
154: w.s.high = (unsigned long)uu.s.high >> b;
155: w.s.low = ((unsigned long)uu.s.low >> b) | carries;
156: }
157:
158: return w.ll;
159: }
160: #endif
161:
162: #ifdef L_ashldi3
163: long long
164: __ashldi3 (u, b)
165: long long u;
166: int b;
167: {
168: long_long w;
169: long bm;
170: long_long uu;
171:
172: if (b == 0)
173: return u;
174:
175: uu.ll = u;
176:
177: bm = (sizeof (long) * BITS_PER_UNIT) - b;
178: if (bm <= 0)
179: {
180: w.s.low = 0;
181: w.s.high = (unsigned long)uu.s.low << -bm;
182: }
183: else
184: {
185: unsigned long carries = (unsigned long)uu.s.low >> bm;
186: w.s.low = (unsigned long)uu.s.low << b;
187: w.s.high = ((unsigned long)uu.s.high << b) | carries;
188: }
189:
190: return w.ll;
191: }
192: #endif
193:
194: #ifdef L_ashrdi3
195: long long
196: __ashrdi3 (u, b)
197: long long u;
198: int b;
199: {
200: long_long w;
201: long bm;
202: long_long uu;
203:
204: if (b == 0)
205: return u;
206:
207: uu.ll = u;
208:
209: bm = (sizeof (long) * BITS_PER_UNIT) - b;
210: if (bm <= 0)
211: {
212: /* w.s.high = 1..1 or 0..0 */
213: w.s.high = uu.s.high >> (sizeof (long) * BITS_PER_UNIT - 1);
214: w.s.low = uu.s.high >> -bm;
215: }
216: else
217: {
218: unsigned long carries = (unsigned long)uu.s.high << bm;
219: w.s.high = uu.s.high >> b;
220: w.s.low = ((unsigned long)uu.s.low >> b) | carries;
221: }
222:
223: return w.ll;
224: }
225: #endif
226:
227: #ifdef L_muldi3
228: long long
229: __muldi3 (u, v)
230: long long u, v;
231: {
232: long_long w;
233: long_long uu, vv;
234:
235: uu.ll = u,
236: vv.ll = v;
237:
238: w.ll = __umulsidi3 (uu.s.low, vv.s.low);
239: w.s.high += ((unsigned long) uu.s.low * (unsigned long) vv.s.high
240: + (unsigned long) uu.s.high * (unsigned long) vv.s.low);
241:
242: return w.ll;
243: }
244: #endif
245:
246: #ifdef L_udivmoddi4
247: static const unsigned char __clz_tab[] =
248: {
249: 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,
250: 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,
251: 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,
252: 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,
253: 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,
254: 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,
255: 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,
256: 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,
257: };
258:
259: unsigned long long
260: __udivmoddi4 (n, d, rp)
261: unsigned long long n, d;
262: unsigned long long int *rp;
263: {
264: long_long ww;
265: long_long nn, dd;
266: long_long rr;
267: unsigned long d0, d1, n0, n1, n2;
268: unsigned long q0, q1;
269: unsigned b, bm;
270:
271: nn.ll = n;
272: dd.ll = d;
273:
274: d0 = dd.s.low;
275: d1 = dd.s.high;
276: n0 = nn.s.low;
277: n1 = nn.s.high;
278:
279: #if !UDIV_NEEDS_NORMALIZATION
280: if (d1 == 0)
281: {
282: if (d0 > n1)
283: {
284: /* 0q = nn / 0D */
285:
286: udiv_qrnnd (q0, n0, n1, n0, d0);
287: q1 = 0;
288:
289: /* Remainder in n0. */
290: }
291: else
292: {
293: /* qq = NN / 0d */
294:
295: if (d0 == 0)
296: d0 = 1 / d0; /* Divide intentionally by zero. */
297:
298: udiv_qrnnd (q1, n1, 0, n1, d0);
299: udiv_qrnnd (q0, n0, n1, n0, d0);
300:
301: /* Remainder in n0. */
302: }
303:
304: if (rp != 0)
305: {
306: rr.s.low = n0;
307: rr.s.high = 0;
308: *rp = rr.ll;
309: }
310: }
311:
312: #else /* UDIV_NEEDS_NORMALIZATION */
313:
314: if (d1 == 0)
315: {
316: if (d0 > n1)
317: {
318: /* 0q = nn / 0D */
319:
320: count_leading_zeros (bm, d0);
321:
322: if (bm != 0)
323: {
324: /* Normalize, i.e. make the most significant bit of the
325: denominator set. */
326:
327: d0 = d0 << bm;
328: n1 = (n1 << bm) | (n0 >> (LONG_TYPE_SIZE - bm));
329: n0 = n0 << bm;
330: }
331:
332: udiv_qrnnd (q0, n0, n1, n0, d0);
333: q1 = 0;
334:
335: /* Remainder in n0 >> bm. */
336: }
337: else
338: {
339: /* qq = NN / 0d */
340:
341: if (d0 == 0)
342: d0 = 1 / d0; /* Divide intentionally by zero. */
343:
344: count_leading_zeros (bm, d0);
345:
346: if (bm == 0)
347: {
348: /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
349: conclude (the most significant bit of n1 is set) /\ (the
350: leading quotient digit q1 = 1).
351:
352: This special case is necessary, not an optimization.
353: (Shifts counts of LONG_TYPE_SIZE are undefined.) */
354:
355: n1 -= d0;
356: q1 = 1;
357: }
358: else
359: {
360: /* Normalize. */
361:
362: b = LONG_TYPE_SIZE - bm;
363:
364: d0 = d0 << bm;
365: n2 = n1 >> b;
366: n1 = (n1 << bm) | (n0 >> b);
367: n0 = n0 << bm;
368:
369: udiv_qrnnd (q1, n1, n2, n1, d0);
370: }
371:
372: /* n1 != d0... */
373:
374: udiv_qrnnd (q0, n0, n1, n0, d0);
375:
376: /* Remainder in n0 >> bm. */
377: }
378:
379: if (rp != 0)
380: {
381: rr.s.low = n0 >> bm;
382: rr.s.high = 0;
383: *rp = rr.ll;
384: }
385: }
386: #endif /* UDIV_NEEDS_NORMALIZATION */
387:
388: else
389: {
390: if (d1 > n1)
391: {
392: /* 00 = nn / DD */
393:
394: q0 = 0;
395: q1 = 0;
396:
397: /* Remainder in n1n0. */
398: if (rp != 0)
399: {
400: rr.s.low = n0;
401: rr.s.high = n1;
402: *rp = rr.ll;
403: }
404: }
405: else
406: {
407: /* 0q = NN / dd */
408:
409: count_leading_zeros (bm, d1);
410: if (bm == 0)
411: {
412: /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
413: conclude (the most significant bit of n1 is set) /\ (the
414: quotient digit q0 = 0 or 1).
415:
416: This special case is necessary, not an optimization. */
417:
418: /* The condition on the next line takes advantage of that
419: n1 >= d1 (true due to program flow). */
420: if (n1 > d1 || n0 >= d0)
421: {
422: q0 = 1;
423: sub_ddmmss (n1, n0, n1, n0, d1, d0);
424: }
425: else
426: q0 = 0;
427:
428: q1 = 0;
429:
430: if (rp != 0)
431: {
432: rr.s.low = n0;
433: rr.s.high = n1;
434: *rp = rr.ll;
435: }
436: }
437: else
438: {
439: unsigned long m1, m0;
440: /* Normalize. */
441:
442: b = LONG_TYPE_SIZE - bm;
443:
444: d1 = (d1 << bm) | (d0 >> b);
445: d0 = d0 << bm;
446: n2 = n1 >> b;
447: n1 = (n1 << bm) | (n0 >> b);
448: n0 = n0 << bm;
449:
450: udiv_qrnnd (q0, n1, n2, n1, d1);
451: umul_ppmm (m1, m0, q0, d0);
452:
453: if (m1 > n1 || (m1 == n1 && m0 > n0))
454: {
455: q0--;
456: sub_ddmmss (m1, m0, m1, m0, d1, d0);
457: }
458:
459: q1 = 0;
460:
461: /* Remainder in (n1n0 - m1m0) >> bm. */
462: if (rp != 0)
463: {
464: sub_ddmmss (n1, n0, n1, n0, m1, m0);
465: rr.s.low = (n1 << b) | (n0 >> bm);
466: rr.s.high = n1 >> bm;
467: *rp = rr.ll;
468: }
469: }
470: }
471: }
472:
473: ww.s.low = q0;
474: ww.s.high = q1;
475: return ww.ll;
476: }
477: #endif
478:
479: #ifdef L_divdi3
480: unsigned long long __udivmoddi4 ();
481: long long
482: __divdi3 (u, v)
483: long long u, v;
484: {
485: int c = 0;
486: long_long uu, vv;
487: long long w;
488:
489: uu.ll = u;
490: vv.ll = v;
491:
492: if (uu.s.high < 0)
493: c = ~c,
494: uu.ll = __negdi2 (uu.ll);
495: if (vv.s.high < 0)
496: c = ~c,
497: vv.ll = __negdi2 (vv.ll);
498:
499: w = __udivmoddi4 (uu.ll, vv.ll, (unsigned long long *) 0);
500: if (c)
501: w = __negdi2 (w);
502:
503: return w;
504: }
505: #endif
506:
507: #ifdef L_moddi3
508: unsigned long long __udivmoddi4 ();
509: long long
510: __moddi3 (u, v)
511: long long u, v;
512: {
513: int c = 0;
514: long_long uu, vv;
515: long long w;
516:
517: uu.ll = u;
518: vv.ll = v;
519:
520: if (uu.s.high < 0)
521: c = ~c,
522: uu.ll = __negdi2 (uu.ll);
523: if (vv.s.high < 0)
524: vv.ll = __negdi2 (vv.ll);
525:
526: (void) __udivmoddi4 (uu.ll, vv.ll, &w);
527: if (c)
528: w = __negdi2 (w);
529:
530: return w;
531: }
532: #endif
533:
534: #ifdef L_umoddi3
535: unsigned long long __udivmoddi4 ();
536: unsigned long long
537: __umoddi3 (u, v)
538: unsigned long long u, v;
539: {
540: long long w;
541:
542: (void) __udivmoddi4 (u, v, &w);
543:
544: return w;
545: }
546: #endif
547:
548: #ifdef L_udivdi3
549: unsigned long long __udivmoddi4 ();
550: unsigned long long
551: __udivdi3 (n, d)
552: unsigned long long n, d;
553: {
554: return __udivmoddi4 (n, d, (unsigned long long *) 0);
555: }
556: #endif
557:
558: #ifdef L_cmpdi2
559: SItype
560: __cmpdi2 (a, b)
561: long long a, b;
562: {
563: long_long au, bu;
564:
565: au.ll = a, bu.ll = b;
566:
567: if (au.s.high < bu.s.high)
568: return 0;
569: else if (au.s.high > bu.s.high)
570: return 2;
571: if ((unsigned long) au.s.low < (unsigned long) bu.s.low)
572: return 0;
573: else if ((unsigned long) au.s.low > (unsigned long) bu.s.low)
574: return 2;
575: return 1;
576: }
577: #endif
578:
579: #ifdef L_ucmpdi2
580: SItype
581: __ucmpdi2 (a, b)
582: long long a, b;
583: {
584: long_long au, bu;
585:
586: au.ll = a, bu.ll = b;
587:
588: if ((unsigned long) au.s.high < (unsigned long) bu.s.high)
589: return 0;
590: else if ((unsigned long) au.s.high > (unsigned long) bu.s.high)
591: return 2;
592: if ((unsigned long) au.s.low < (unsigned long) bu.s.low)
593: return 0;
594: else if ((unsigned long) au.s.low > (unsigned long) bu.s.low)
595: return 2;
596: return 1;
597: }
598: #endif
599:
600: #ifdef L_fixunsdfdi
601: #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
602: #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
603:
604: long long
605: __fixunsdfdi (a)
606: double a;
607: {
608: double b;
609: unsigned long long v;
610:
611: if (a < 0)
612: return 0;
613:
614: /* Compute high word of result, as a flonum. */
615: b = (a / HIGH_WORD_COEFF);
616: /* Convert that to fixed (but not to long long!),
617: and shift it into the high word. */
618: v = (unsigned long int) b;
619: v <<= WORD_SIZE;
620: /* Remove high part from the double, leaving the low part as flonum. */
621: a -= (double)v;
622: /* Convert that to fixed (but not to long long!) and add it in.
623: Sometimes A comes out negative. This is significant, since
624: A has more bits than a long int does. */
625: if (a < 0)
626: v -= (unsigned long int) (- a);
627: else
628: v += (unsigned long int) a;
629: return v;
630: }
631: #endif
632:
633: #ifdef L_fixdfdi
634: long long
635: __fixdfdi (a)
636: double a;
637: {
638: if (a < 0)
639: return - __fixunsdfdi (-a);
640: return __fixunsdfdi (a);
641: }
642: #endif
643:
644: #ifdef L_fixunssfdi
645: #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
646: #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
647:
648: long long
649: __fixunssfdi (float original_a)
650: {
651: /* Convert the float to a double, because that is surely not going
652: to lose any bits. Some day someone else can write a faster version
653: that avoids converting to double, and verify it really works right. */
654: double a = original_a;
655: double b;
656: unsigned long long v;
657:
658: if (a < 0)
659: return 0;
660:
661: /* Compute high word of result, as a flonum. */
662: b = (a / HIGH_WORD_COEFF);
663: /* Convert that to fixed (but not to long long!),
664: and shift it into the high word. */
665: v = (unsigned long int) b;
666: v <<= WORD_SIZE;
667: /* Remove high part from the double, leaving the low part as flonum. */
668: a -= (double)v;
669: /* Convert that to fixed (but not to long long!) and add it in.
670: Sometimes A comes out negative. This is significant, since
671: A has more bits than a long int does. */
672: if (a < 0)
673: v -= (unsigned long int) (- a);
674: else
675: v += (unsigned long int) a;
676: return v;
677: }
678: #endif
679:
680: #ifdef L_fixsfdi
681: long long
682: __fixsfdi (float a)
683: {
684: if (a < 0)
685: return - __fixunssfdi (-a);
686: return __fixunssfdi (a);
687: }
688: #endif
689:
690: #ifdef L_floatdidf
691: #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
692: #define HIGH_HALFWORD_COEFF (((long long) 1) << (WORD_SIZE / 2))
693: #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
694:
695: double
696: __floatdidf (u)
697: long long u;
698: {
699: double d;
700: int negate = 0;
701:
702: if (u < 0)
703: u = -u, negate = 1;
704:
705: d = (unsigned int) (u >> WORD_SIZE);
706: d *= HIGH_HALFWORD_COEFF;
707: d *= HIGH_HALFWORD_COEFF;
708: d += (unsigned int) (u & (HIGH_WORD_COEFF - 1));
709:
710: return (negate ? -d : d);
711: }
712: #endif
713:
714: #ifdef L_floatdisf
715: #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
716: #define HIGH_HALFWORD_COEFF (((long long) 1) << (WORD_SIZE / 2))
717: #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
718:
719: float
720: __floatdisf (u)
721: long long u;
722: {
723: float f;
724: int negate = 0;
725:
726: if (u < 0)
727: u = -u, negate = 1;
728:
729: f = (unsigned int) (u >> WORD_SIZE);
730: f *= HIGH_HALFWORD_COEFF;
731: f *= HIGH_HALFWORD_COEFF;
732: f += (unsigned int) (u & (HIGH_WORD_COEFF - 1));
733:
734: return (negate ? -f : f);
735: }
736: #endif
737:
738: #ifdef L_fixunsdfsi
739: #include "limits.h"
740:
741: unsigned SItype
742: __fixunsdfsi (a)
743: double a;
744: {
745: if (a >= - (double) LONG_MIN)
746: return (SItype) (a + LONG_MIN) - LONG_MIN;
747: return (SItype) a;
748: }
749: #endif
750:
751: #ifdef L_fixunssfsi
752: #include "limits.h"
753:
754: unsigned SItype
755: __fixunssfsi (float a)
756: {
757: if (a >= - (float) LONG_MIN)
758: return (SItype) (a + LONG_MIN) - LONG_MIN;
759: return (SItype) a;
760: }
761: #endif
762:
763: #ifdef L_varargs
764: #ifdef __i860__
765: #ifdef SVR4
766: asm (" .text");
767: asm (" .align 4");
768:
769: asm (".globl __builtin_saveregs");
770: asm ("__builtin_saveregs:");
771: asm (" andnot 0x0f,%sp,%sp"); /* round down to 16-byte boundary */
772: asm (" adds -96,%sp,%sp"); /* allocate stack space for reg save
773: area and also for a new va_list
774: structure */
775: /* Save all argument registers in the arg reg save area. The
776: arg reg save area must have the following layout (according
777: to the svr4 ABI):
778:
779: struct {
780: union {
781: float freg[8];
782: double dreg[4];
783: } float_regs;
784: long ireg[12];
785: };
786: */
787:
788: asm (" fst.q %f8, 0(%sp)"); /* save floating regs (f8-f15) */
789: asm (" fst.q %f12,16(%sp)");
790:
791: asm (" st.l %r16,32(%sp)"); /* save integer regs (r16-r27) */
792: asm (" st.l %r17,36(%sp)");
793: asm (" st.l %r18,40(%sp)");
794: asm (" st.l %r19,44(%sp)");
795: asm (" st.l %r20,48(%sp)");
796: asm (" st.l %r21,52(%sp)");
797: asm (" st.l %r22,56(%sp)");
798: asm (" st.l %r23,60(%sp)");
799: asm (" st.l %r24,64(%sp)");
800: asm (" st.l %r25,68(%sp)");
801: asm (" st.l %r26,72(%sp)");
802: asm (" st.l %r27,76(%sp)");
803:
804: asm (" adds 80,%sp,%r16"); /* compute the address of the new
805: va_list structure. Put in into
806: r16 so that it will be returned
807: to the caller. */
808:
809: /* Initialize all fields of the new va_list structure. This
810: structure looks like:
811:
812: typedef struct {
813: unsigned long ireg_used;
814: unsigned long freg_used;
815: long *reg_base;
816: long *mem_ptr;
817: } va_list;
818: */
819:
820: asm (" st.l %r0, 0(%r16)"); /* nfixed */
821: asm (" st.l %r0, 4(%r16)"); /* nfloating */
822: asm (" st.l %sp, 8(%r16)"); /* __va_ctl points to __va_struct. */
823: asm (" bri %r1"); /* delayed return */
824: asm (" st.l %r28,12(%r16)"); /* pointer to overflow args */
825:
826: #else /* not SVR4 */
827: asm (" .text");
828: asm (" .align 4");
829:
830: asm (".globl ___builtin_saveregs");
831: asm ("___builtin_saveregs:");
832: asm (" mov sp,r30");
833: asm (" andnot 0x0f,sp,sp");
834: asm (" adds -96,sp,sp"); /* allocate sufficient space on the stack */
835:
836: /* Fill in the __va_struct. */
837: asm (" st.l r16, 0(sp)"); /* save integer regs (r16-r27) */
838: asm (" st.l r17, 4(sp)"); /* int fixed[12] */
839: asm (" st.l r18, 8(sp)");
840: asm (" st.l r19,12(sp)");
841: asm (" st.l r20,16(sp)");
842: asm (" st.l r21,20(sp)");
843: asm (" st.l r22,24(sp)");
844: asm (" st.l r23,28(sp)");
845: asm (" st.l r24,32(sp)");
846: asm (" st.l r25,36(sp)");
847: asm (" st.l r26,40(sp)");
848: asm (" st.l r27,44(sp)");
849:
850: asm (" fst.q f8, 48(sp)"); /* save floating regs (f8-f15) */
851: asm (" fst.q f12,64(sp)"); /* int floating[8] */
852:
853: /* Fill in the __va_ctl. */
854: asm (" st.l sp, 80(sp)"); /* __va_ctl points to __va_struct. */
855: asm (" st.l r28,84(sp)"); /* pointer to more args */
856: asm (" st.l r0, 88(sp)"); /* nfixed */
857: asm (" st.l r0, 92(sp)"); /* nfloating */
858:
859: asm (" adds 80,sp,r16"); /* return address of the __va_ctl. */
860: asm (" bri r1");
861: asm (" mov r30,sp");
862: /* recover stack and pass address to start
863: of data. */
864: #endif /* not SVR4 */
865: #else /* not __i860__ */
866: #ifdef __sparc__
867: asm (".global ___builtin_saveregs");
868: asm ("___builtin_saveregs:");
869: asm ("st %i0,[%fp+68]");
870: asm ("st %i1,[%fp+72]");
871: asm ("st %i2,[%fp+76]");
872: asm ("st %i3,[%fp+80]");
873: asm ("st %i4,[%fp+84]");
874: asm ("retl");
875: asm ("st %i5,[%fp+88]");
876: #else /* not __sparc__ */
877: #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
878:
879: asm (" .text");
880: asm (" .ent __builtin_saveregs");
881: asm (" .globl __builtin_saveregs");
882: asm ("__builtin_saveregs:");
883: asm (" sw $4,0($30)");
884: asm (" sw $5,4($30)");
885: asm (" sw $6,8($30)");
886: asm (" sw $7,12($30)");
887: asm (" j $31");
888: asm (" .end __builtin_saveregs");
889: #else /* not __mips__, etc. */
890: __builtin_saveregs ()
891: {
892: abort ();
893: }
894: #endif /* not __mips__ */
895: #endif /* not __sparc__ */
896: #endif /* not __i860__ */
897: #endif
898:
899: #ifdef L_eprintf
900: #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
901: #include <stdio.h>
902: /* This is used by the `assert' macro. */
903: void
904: __eprintf (string, expression, line, filename)
905: char *string;
906: char *expression;
907: int line;
908: char *filename;
909: {
910: fprintf (stderr, string, expression, line, filename);
911: fflush (stderr);
912: abort ();
913: }
914: #endif
915:
916: #ifdef L_bb
917: /* Avoid warning from ranlib about empty object file. */
918: void
919: __bb_avoid_warning ()
920: {}
921:
922: #if defined (__sun__) && defined (__mc68000__)
923: struct bb
924: {
925: int initialized;
926: char *filename;
927: int *counts;
928: int ncounts;
929: int zero_word;
930: int *addresses;
931: };
932:
933: extern int ___tcov_init;
934:
935: __bb_init_func (blocks)
936: struct bb *blocks;
937: {
938: if (! ___tcov_init)
939: ___tcov_init_func ();
940:
941: ___bb_link (blocks->filename, blocks->counts, blocks->ncounts);
942: }
943:
944: #endif
945: #endif
946:
947: /* frills for C++ */
948:
949: #ifdef L_builtin_new
950: typedef void (*vfp)(void);
951:
952: extern vfp __new_handler;
953:
954: void *
955: __builtin_new (sz)
956: long sz;
957: {
958: void *p;
959:
960: p = (void *) malloc (sz);
961: if (p == 0)
962: (*__new_handler) ();
963: return p;
964: }
965: #endif
966:
967: #ifdef L_builtin_New
968: typedef void (*vfp)(void);
969:
970: static void default_new_handler ();
971:
972: vfp __new_handler = default_new_handler;
973:
974: void *
975: __builtin_vec_new (p, maxindex, size, ctor)
976: void *p;
977: int maxindex, size;
978: void (*ctor)(void *);
979: {
980: int i, nelts = maxindex + 1;
981: void *rval;
982:
983: if (p == 0)
984: p = (void *)__builtin_new (nelts * size);
985:
986: rval = p;
987:
988: for (i = 0; i < nelts; i++)
989: {
990: (*ctor) (p);
991: p += size;
992: }
993:
994: return rval;
995: }
996:
997: vfp
998: __set_new_handler (handler)
999: vfp handler;
1000: {
1001: vfp prev_handler;
1002:
1003: prev_handler = __new_handler;
1004: if (handler == 0) handler = default_new_handler;
1005: __new_handler = handler;
1006: return prev_handler;
1007: }
1008:
1009: vfp
1010: set_new_handler (handler)
1011: vfp handler;
1012: {
1013: return __set_new_handler (handler);
1014: }
1015:
1016: static void
1017: default_new_handler ()
1018: {
1019: /* don't use fprintf (stderr, ...) because it may need to call malloc. */
1020: /* This should really print the name of the program, but that is hard to
1021: do. We need a standard, clean way to get at the name. */
1022: write (2, "Virtual memory exceeded in `new'\n", 33);
1023: /* don't call exit () because that may call global destructors which
1024: may cause a loop. */
1025: _exit (-1);
1026: }
1027: #endif
1028:
1029: #ifdef L_builtin_del
1030: typedef void (*vfp)(void);
1031:
1032: void
1033: __builtin_delete (ptr)
1034: void *ptr;
1035: {
1036: if (ptr)
1037: free (ptr);
1038: }
1039:
1040: void
1041: __builtin_vec_delete (ptr, maxindex, size, dtor, auto_delete_vec, auto_delete)
1042: void *ptr;
1043: int maxindex, size;
1044: void (*dtor)();
1045: int auto_delete;
1046: {
1047: int i, nelts = maxindex + 1;
1048: void *p = ptr;
1049:
1050: ptr += nelts * size;
1051:
1052: for (i = 0; i < nelts; i++)
1053: {
1054: ptr -= size;
1055: (*dtor) (ptr, auto_delete);
1056: }
1057:
1058: if (auto_delete_vec)
1059: __builtin_delete (p);
1060: }
1061:
1062: #endif
1063:
1064: #ifdef L_shtab
1065: unsigned int __shtab[] = {
1066: 0x00000001, 0x00000002, 0x00000004, 0x00000008,
1067: 0x00000010, 0x00000020, 0x00000040, 0x00000080,
1068: 0x00000100, 0x00000200, 0x00000400, 0x00000800,
1069: 0x00001000, 0x00002000, 0x00004000, 0x00008000,
1070: 0x00010000, 0x00020000, 0x00040000, 0x00080000,
1071: 0x00100000, 0x00200000, 0x00400000, 0x00800000,
1072: 0x01000000, 0x02000000, 0x04000000, 0x08000000,
1073: 0x10000000, 0x20000000, 0x40000000, 0x80000000
1074: };
1075: #endif
1076:
1077: #ifdef L_clear_cache
1078: /* Clear part of an instruction cache. */
1079:
1080: #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1081:
1082: void
1083: __clear_cache (beg, end)
1084: char *beg, *end;
1085: {
1086: #ifdef INSN_CACHE_SIZE
1087: static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1088: static int initialized = 0;
1089: int offset;
1090: unsigned int start_addr, end_addr;
1091: typedef (*function_ptr) ();
1092:
1093: #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1094: /* It's cheaper to clear the whole cache.
1095: Put in a series of jump instructions so that calling the beginning
1096: of the cache will clear the whole thing. */
1097:
1098: if (! initialized)
1099: {
1100: int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1101: & -INSN_CACHE_LINE_WIDTH);
1102: int end_ptr = ptr + INSN_CACHE_SIZE;
1103:
1104: while (ptr < end_ptr)
1105: {
1106: *(INSTRUCTION_TYPE *)ptr
1107: = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1108: ptr += INSN_CACHE_LINE_WIDTH;
1109: }
1110: *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1111:
1112: initialized = 1;
1113: }
1114:
1115: /* Call the beginning of the sequence. */
1116: (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1117: & -INSN_CACHE_LINE_WIDTH))
1118: ());
1119:
1120: #else /* Cache is large. */
1121:
1122: if (! initialized)
1123: {
1124: int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1125: & -INSN_CACHE_LINE_WIDTH);
1126:
1127: while (ptr < (int) array + sizeof array)
1128: {
1129: *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1130: ptr += INSN_CACHE_LINE_WIDTH;
1131: }
1132:
1133: initialized = 1;
1134: }
1135:
1136: /* Find the location in array that occupies the same cache line as BEG. */
1137:
1138: offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1139: start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1140: & -INSN_CACHE_PLANE_SIZE)
1141: + offset);
1142:
1143: /* Compute the cache alignment of the place to stop clearing. */
1144: #if 0 /* This is not needed for gcc's purposes. */
1145: /* If the block to clear is bigger than a cache plane,
1146: we clear the entire cache, and OFFSET is already correct. */
1147: if (end < beg + INSN_CACHE_PLANE_SIZE)
1148: #endif
1149: offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1150: & -INSN_CACHE_LINE_WIDTH)
1151: & (INSN_CACHE_PLANE_SIZE - 1));
1152:
1153: #if INSN_CACHE_DEPTH > 1
1154: end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1155: if (end_addr <= start_addr)
1156: end_addr += INSN_CACHE_PLANE_SIZE;
1157:
1158: for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1159: {
1160: int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1161: int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1162:
1163: while (addr != stop)
1164: {
1165: /* Call the return instruction at ADDR. */
1166: ((function_ptr) addr) ();
1167:
1168: addr += INSN_CACHE_LINE_WIDTH;
1169: }
1170: }
1171: #else /* just one plane */
1172: do
1173: {
1174: /* Call the return instruction at START_ADDR. */
1175: ((function_ptr) start_addr) ();
1176:
1177: start_addr += INSN_CACHE_LINE_WIDTH;
1178: }
1179: while ((start_addr % INSN_CACHE_SIZE) != offset);
1180: #endif /* just one plane */
1181: #endif /* Cache is large */
1182: #endif /* Cache exists */
1183: }
1184:
1185: #endif /* L_clear_cache */
1186:
1187: #ifdef L_trampoline
1188:
1189: /* Jump to a trampoline, loading the static chain address. */
1190:
1191: #ifdef TRANSFER_FROM_TRAMPOLINE
1192: TRANSFER_FROM_TRAMPOLINE
1193: #endif
1194:
1195: #ifdef __convex__
1196:
1197: /* Make stack executable so we can call trampolines on stack.
1198: This is called from INITIALIZE_TRAMPOLINE in convex.h. */
1199:
1200: #include <sys/mman.h>
1201: #include <sys/vmparam.h>
1202: #include <machine/machparam.h>
1203:
1204: void
1205: __enable_execute_stack ()
1206: {
1207: int fp;
1208: static unsigned lowest = USRSTACK;
1209: unsigned current = (unsigned) &fp & -NBPG;
1210:
1211: if (lowest > current)
1212: {
1213: unsigned len = lowest - current;
1214: mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1215: lowest = current;
1216: }
1217:
1218: /* Clear instruction cache in case an old trampoline is in it. */
1219: asm ("pich");
1220: }
1221: #endif /* __convex__ */
1222: #endif /* L_trampoline */
1223:
1224: #ifdef L__main
1225:
1226: #include "gbl-ctors.h"
1227:
1228: /* Run all the global destructors on exit from the program. */
1229:
1230: void
1231: __do_global_dtors ()
1232: {
1233: #ifdef DO_GLOBAL_DTORS_BODY
1234: DO_GLOBAL_DTORS_BODY;
1235: #else
1236: int nptrs = *(int *)__DTOR_LIST__;
1237: int i;
1238:
1239: /* Some systems place the number of pointers
1240: in the first word of the table.
1241: On other systems, that word is -1.
1242: In all cases, the table is null-terminated. */
1243:
1244: /* If the length is not recorded, count up to the null. */
1245: if (nptrs == -1)
1246: for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++);
1247:
1248: /* GNU LD format. */
1249: for (i = nptrs; i >= 1; i--)
1250: __DTOR_LIST__[i] ();
1251: #endif
1252: }
1253:
1254: #ifndef INIT_SECTION_ASM_OP
1255: /* Run all the global constructors on entry to the program. */
1256:
1257: #ifndef ON_EXIT /* DO_GLOBAL_CTORS_BODY uses ON_EXIT */
1258: #define ON_EXIT(a, b)
1259: #else
1260: /* Make sure the exit routine is pulled in to define the globals as
1261: bss symbols, just in case the linker does not automatically pull
1262: bss definitions from the library. */
1263:
1264: extern int _exit_dummy_decl;
1265: int *_exit_dummy_ref = &_exit_dummy_decl;
1266: #endif /* ON_EXIT */
1267:
1268: void
1269: __do_global_ctors ()
1270: {
1271: DO_GLOBAL_CTORS_BODY;
1272: }
1273:
1274: /* Subroutine called automatically by `main'.
1275: Compiling a global function named `main'
1276: produces an automatic call to this function at the beginning.
1277:
1278: For many systems, this routine calls __do_global_ctors.
1279: For systems which support a .init section we use the .init section
1280: to run __do_global_ctors, so we need not do anything here. */
1281:
1282: void
1283: __main ()
1284: {
1285: /* Support recursive calls to `main': run initializers just once. */
1286: static initialized = 0;
1287: if (! initialized)
1288: {
1289: initialized = 1;
1290: __do_global_ctors ();
1291: }
1292: }
1293: #endif /* no INIT_SECTION_ASM_OP */
1294:
1295: #endif /* L__main */
1296:
1297: #ifdef L_exit
1298:
1299: #include "gbl-ctors.h"
1300:
1301: /* Provide default definitions for the lists of constructors and
1302: destructors, so that we don't get linker errors. These symbols are
1303: intentionally bss symbols, so that gld and/or collect will provide
1304: the right values. */
1305:
1306: /* We declare the lists here with two elements each,
1307: so that they are valid empty lists if no other definition is loaded. */
1308: #ifndef INIT_SECTION_ASM_OP
1309: func_ptr __CTOR_LIST__[2];
1310: func_ptr __DTOR_LIST__[2];
1311: #endif /* INIT_SECTION_ASM_OP */
1312:
1313: #ifndef ON_EXIT
1314:
1315: /* If we have no known way of registering our own __do_global_dtors
1316: routine so that it will be invoked at program exit time, then we
1317: have to define our own exit routine which will get this to happen. */
1318:
1319: extern void __do_global_dtors ();
1320: extern void _cleanup ();
1321: extern void _exit ();
1322:
1323: void
1324: exit (status)
1325: int status;
1326: {
1327: __do_global_dtors ();
1328: #ifdef EXIT_BODY
1329: EXIT_BODY;
1330: #else
1331: _cleanup ();
1332: #endif
1333: _exit (status);
1334: }
1335:
1336: #else
1337: int _exit_dummy_decl = 0; /* prevent compiler & linker warnings */
1338: #endif
1339:
1340: #endif /* L_exit */
1341:
1342: /* In a.out systems, we need to have these dummy constructor and destructor
1343: lists in the library.
1344:
1345: When using `collect', the first link will resolve __CTOR_LIST__
1346: and __DTOR_LIST__ to these symbols. We will then run "nm" on the
1347: result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
1348: Since we don't do the second link if no constructors existed, these
1349: dummies must be fully functional empty lists.
1350:
1351: When using `gnu ld', these symbols will be used if there are no
1352: constructors. If there are constructors, the N_SETV symbol defined
1353: by the linker from the N_SETT's in input files will define __CTOR_LIST__
1354: and __DTOR_LIST__ rather than its being allocated as common storage
1355: by the definitions below.
1356:
1357: When using a linker that supports constructor and destructor segments,
1358: these definitions will not be used, since crtbegin.o and crtend.o
1359: (from crtstuff.c) will have already defined __CTOR_LIST__ and
1360: __DTOR_LIST__. The crt*.o files are passed directly to the linker
1361: on its command line, by gcc. */
1362:
1363: /* The list needs two elements: one is ignored (the old count); the
1364: second is the terminating zero. Since both values are zero, this
1365: declaration is not initialized, and it becomes `common'. */
1366:
1367: #ifdef L_ctor_list
1368: #include "gbl-ctors.h"
1369: func_ptr __CTOR_LIST__[2];
1370: #endif
1371:
1372: #ifdef L_dtor_list
1373: #include "gbl-ctors.h"
1374: func_ptr __DTOR_LIST__[2];
1375: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.