![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libgcc1.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 libgcc1.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Subroutines needed by GCC output code on some machines. */
2: /* Compile this file with the Unix C compiler! */
3: /* Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
4:
5: This file is free software; you can redistribute it and/or modify it
6: under the terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option) any
8: later version.
9:
10: In addition to the permissions in the GNU General Public License, the
11: Free Software Foundation gives you unlimited permission to link the
12: compiled version of this file with other programs, and to distribute
13: those programs without any restriction coming from the use of this
14: file. (The General Public License restrictions do apply in other
15: respects; for example, they cover modification of the file, and
16: distribution when not linked into another program.)
17:
18: This file is distributed in the hope that it will be useful, but
19: WITHOUT ANY WARRANTY; without even the implied warranty of
20: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21: General Public License for more details.
22:
23: You should have received a copy of the GNU General Public License
24: along with this program; see the file COPYING. If not, write to
25: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26:
27: /* As a special exception, if you link this library with files
28: compiled with GCC to produce an executable, this does not cause
29: the resulting executable to be covered by the GNU General Public License.
30: This exception does not however invalidate any other reasons why
31: the executable file might be covered by the GNU General Public License. */
32:
33: #include "config.h"
34:
35: /* Don't use `fancy_abort' here even if config.h says to use it. */
36: #ifdef abort
37: #undef abort
38: #endif
39:
40: /* On some machines, cc is really GCC. For these machines, we can't
41: expect these functions to be properly compiled unless GCC open codes
42: the operation (which is precisely when the function won't be used).
43: So allow tm.h to specify ways of accomplishing the operations
44: by defining the macros perform_*.
45:
46: On a machine where cc is some other compiler, there is usually no
47: reason to define perform_*. The other compiler normally has other ways
48: of implementing all of these operations.
49:
50: In some cases a certain machine may come with GCC installed as cc
51: or may have some other compiler. Then it may make sense for tm.h
52: to define perform_* only if __GNUC__ is defined. */
53:
54: #ifndef perform_mulsi3
55: #define perform_mulsi3(a, b) return a * b
56: #endif
57:
58: #ifndef perform_divsi3
59: #define perform_divsi3(a, b) return a / b
60: #endif
61:
62: #ifndef perform_udivsi3
63: #define perform_udivsi3(a, b) return a / b
64: #endif
65:
66: #ifndef perform_modsi3
67: #define perform_modsi3(a, b) return a % b
68: #endif
69:
70: #ifndef perform_umodsi3
71: #define perform_umodsi3(a, b) return a % b
72: #endif
73:
74: #ifndef perform_lshrsi3
75: #define perform_lshrsi3(a, b) return a >> b
76: #endif
77:
78: #ifndef perform_lshlsi3
79: #define perform_lshlsi3(a, b) return a << b
80: #endif
81:
82: #ifndef perform_ashrsi3
83: #define perform_ashrsi3(a, b) return a >> b
84: #endif
85:
86: #ifndef perform_ashlsi3
87: #define perform_ashlsi3(a, b) return a << b
88: #endif
89:
90: #ifndef perform_adddf3
91: #define perform_adddf3(a, b) return a + b
92: #endif
93:
94: #ifndef perform_subdf3
95: #define perform_subdf3(a, b) return a - b
96: #endif
97:
98: #ifndef perform_muldf3
99: #define perform_muldf3(a, b) return a * b
100: #endif
101:
102: #ifndef perform_divdf3
103: #define perform_divdf3(a, b) return a / b
104: #endif
105:
106: #ifndef perform_addsf3
107: #define perform_addsf3(a, b) return INTIFY (a + b)
108: #endif
109:
110: #ifndef perform_subsf3
111: #define perform_subsf3(a, b) return INTIFY (a - b)
112: #endif
113:
114: #ifndef perform_mulsf3
115: #define perform_mulsf3(a, b) return INTIFY (a * b)
116: #endif
117:
118: #ifndef perform_divsf3
119: #define perform_divsf3(a, b) return INTIFY (a / b)
120: #endif
121:
122: #ifndef perform_negdf2
123: #define perform_negdf2(a) return -a
124: #endif
125:
126: #ifndef perform_negsf2
127: #define perform_negsf2(a) return INTIFY (-a)
128: #endif
129:
130: #ifndef perform_fixdfsi
1.1.1.3 ! root 131: #define perform_fixdfsi(a) return (nongcc_SI_type) a;
1.1 root 132: #endif
133:
134: #ifndef perform_fixsfsi
1.1.1.3 ! root 135: #define perform_fixsfsi(a) return (nongcc_SI_type) a
1.1 root 136: #endif
137:
138: #ifndef perform_floatsidf
139: #define perform_floatsidf(a) return (double) a
140: #endif
141:
142: #ifndef perform_floatsisf
143: #define perform_floatsisf(a) return INTIFY ((float) a)
144: #endif
145:
146: #ifndef perform_extendsfdf2
147: #define perform_extendsfdf2(a) return a
148: #endif
149:
150: #ifndef perform_truncdfsf2
151: #define perform_truncdfsf2(a) return INTIFY (a)
152: #endif
153:
154: /* Note that eqdf2 returns a value for "true" that is == 0,
155: nedf2 returns a value for "true" that is != 0,
156: gtdf2 returns a value for "true" that is > 0,
157: and so on. */
158:
159: #ifndef perform_eqdf2
160: #define perform_eqdf2(a, b) return !(a == b)
161: #endif
162:
163: #ifndef perform_nedf2
164: #define perform_nedf2(a, b) return a != b
165: #endif
166:
167: #ifndef perform_gtdf2
168: #define perform_gtdf2(a, b) return a > b
169: #endif
170:
171: #ifndef perform_gedf2
172: #define perform_gedf2(a, b) return (a >= b) - 1
173: #endif
174:
175: #ifndef perform_ltdf2
176: #define perform_ltdf2(a, b) return -(a < b)
177: #endif
178:
179: #ifndef perform_ledf2
180: #define perform_ledf2(a, b) return 1 - (a <= b)
181: #endif
182:
183: #ifndef perform_eqsf2
184: #define perform_eqsf2(a, b) return !(a == b)
185: #endif
186:
187: #ifndef perform_nesf2
188: #define perform_nesf2(a, b) return a != b
189: #endif
190:
191: #ifndef perform_gtsf2
192: #define perform_gtsf2(a, b) return a > b
193: #endif
194:
195: #ifndef perform_gesf2
196: #define perform_gesf2(a, b) return (a >= b) - 1
197: #endif
198:
199: #ifndef perform_ltsf2
200: #define perform_ltsf2(a, b) return -(a < b)
201: #endif
202:
203: #ifndef perform_lesf2
1.1.1.2 root 204: #define perform_lesf2(a, b) return 1 - (a <= b);
1.1 root 205: #endif
206:
207: /* Define the C data type to use for an SImode value. */
208:
1.1.1.3 ! root 209: #ifndef nongcc_SI_type
! 210: #define nongcc_SI_type long int
1.1 root 211: #endif
212:
213: /* Define the type to be used for returning an SF mode value
214: and the method for turning a float into that type.
215: These definitions work for machines where an SF value is
216: returned in the same register as an int. */
217:
218: #ifndef FLOAT_VALUE_TYPE
219: #define FLOAT_VALUE_TYPE int
220: #endif
221:
222: #ifndef INTIFY
223: #define INTIFY(FLOATVAL) (intify.f = (FLOATVAL), intify.i)
224: #endif
225:
226: #ifndef FLOATIFY
227: #define FLOATIFY(INTVAL) ((INTVAL).f)
228: #endif
229:
230: #ifndef FLOAT_ARG_TYPE
231: #define FLOAT_ARG_TYPE union flt_or_int
232: #endif
233:
234: union flt_or_value { FLOAT_VALUE_TYPE i; float f; };
235:
236: union flt_or_int { int i; float f; };
237:
238:
239: #ifdef L_mulsi3
1.1.1.3 ! root 240: nongcc_SI_type
1.1 root 241: __mulsi3 (a, b)
1.1.1.3 ! root 242: nongcc_SI_type a, b;
1.1 root 243: {
244: perform_mulsi3 (a, b);
245: }
246: #endif
247:
248: #ifdef L_udivsi3
1.1.1.3 ! root 249: nongcc_SI_type
1.1 root 250: __udivsi3 (a, b)
1.1.1.3 ! root 251: unsigned nongcc_SI_type a, b;
1.1 root 252: {
253: perform_udivsi3 (a, b);
254: }
255: #endif
256:
257: #ifdef L_divsi3
1.1.1.3 ! root 258: nongcc_SI_type
1.1 root 259: __divsi3 (a, b)
1.1.1.3 ! root 260: nongcc_SI_type a, b;
1.1 root 261: {
262: perform_divsi3 (a, b);
263: }
264: #endif
265:
266: #ifdef L_umodsi3
1.1.1.3 ! root 267: nongcc_SI_type
1.1 root 268: __umodsi3 (a, b)
1.1.1.3 ! root 269: unsigned nongcc_SI_type a, b;
1.1 root 270: {
271: perform_umodsi3 (a, b);
272: }
273: #endif
274:
275: #ifdef L_modsi3
1.1.1.3 ! root 276: nongcc_SI_type
1.1 root 277: __modsi3 (a, b)
1.1.1.3 ! root 278: nongcc_SI_type a, b;
1.1 root 279: {
280: perform_modsi3 (a, b);
281: }
282: #endif
283:
284: #ifdef L_lshrsi3
1.1.1.3 ! root 285: nongcc_SI_type
1.1 root 286: __lshrsi3 (a, b)
1.1.1.3 ! root 287: unsigned nongcc_SI_type a, b;
1.1 root 288: {
289: perform_lshrsi3 (a, b);
290: }
291: #endif
292:
293: #ifdef L_lshlsi3
1.1.1.3 ! root 294: nongcc_SI_type
1.1 root 295: __lshlsi3 (a, b)
1.1.1.3 ! root 296: unsigned nongcc_SI_type a, b;
1.1 root 297: {
298: perform_lshlsi3 (a, b);
299: }
300: #endif
301:
302: #ifdef L_ashrsi3
1.1.1.3 ! root 303: nongcc_SI_type
1.1 root 304: __ashrsi3 (a, b)
1.1.1.3 ! root 305: nongcc_SI_type a, b;
1.1 root 306: {
307: perform_ashrsi3 (a, b);
308: }
309: #endif
310:
311: #ifdef L_ashlsi3
1.1.1.3 ! root 312: nongcc_SI_type
1.1 root 313: __ashlsi3 (a, b)
1.1.1.3 ! root 314: nongcc_SI_type a, b;
1.1 root 315: {
316: perform_ashlsi3 (a, b);
317: }
318: #endif
319:
320: #ifdef L_divdf3
321: double
322: __divdf3 (a, b)
323: double a, b;
324: {
325: perform_divdf3 (a, b);
326: }
327: #endif
328:
329: #ifdef L_muldf3
330: double
331: __muldf3 (a, b)
332: double a, b;
333: {
334: perform_muldf3 (a, b);
335: }
336: #endif
337:
338: #ifdef L_negdf2
339: double
340: __negdf2 (a)
341: double a;
342: {
343: perform_negdf2 (a);
344: }
345: #endif
346:
347: #ifdef L_adddf3
348: double
349: __adddf3 (a, b)
350: double a, b;
351: {
352: perform_adddf3 (a, b);
353: }
354: #endif
355:
356: #ifdef L_subdf3
357: double
358: __subdf3 (a, b)
359: double a, b;
360: {
361: perform_subdf3 (a, b);
362: }
363: #endif
364:
365: /* Note that eqdf2 returns a value for "true" that is == 0,
366: nedf2 returns a value for "true" that is != 0,
367: gtdf2 returns a value for "true" that is > 0,
368: and so on. */
369:
370: #ifdef L_eqdf2
1.1.1.3 ! root 371: nongcc_SI_type
1.1 root 372: __eqdf2 (a, b)
373: double a, b;
374: {
375: /* Value == 0 iff a == b. */
376: perform_eqdf2 (a, b);
377: }
378: #endif
379:
380: #ifdef L_nedf2
1.1.1.3 ! root 381: nongcc_SI_type
1.1 root 382: __nedf2 (a, b)
383: double a, b;
384: {
385: /* Value != 0 iff a != b. */
386: perform_nedf2 (a, b);
387: }
388: #endif
389:
390: #ifdef L_gtdf2
1.1.1.3 ! root 391: nongcc_SI_type
1.1 root 392: __gtdf2 (a, b)
393: double a, b;
394: {
395: /* Value > 0 iff a > b. */
396: perform_gtdf2 (a, b);
397: }
398: #endif
399:
400: #ifdef L_gedf2
1.1.1.3 ! root 401: nongcc_SI_type
1.1 root 402: __gedf2 (a, b)
403: double a, b;
404: {
405: /* Value >= 0 iff a >= b. */
406: perform_gedf2 (a, b);
407: }
408: #endif
409:
410: #ifdef L_ltdf2
1.1.1.3 ! root 411: nongcc_SI_type
1.1 root 412: __ltdf2 (a, b)
413: double a, b;
414: {
415: /* Value < 0 iff a < b. */
416: perform_ltdf2 (a, b);
417: }
418: #endif
419:
420: #ifdef L_ledf2
1.1.1.3 ! root 421: nongcc_SI_type
1.1 root 422: __ledf2 (a, b)
423: double a, b;
424: {
425: /* Value <= 0 iff a <= b. */
426: perform_ledf2 (a, b);
427: }
428: #endif
429:
430: #ifdef L_fixdfsi
1.1.1.3 ! root 431: nongcc_SI_type
1.1 root 432: __fixdfsi (a)
433: double a;
434: {
435: perform_fixdfsi (a);
436: }
437: #endif
438:
439: #ifdef L_fixsfsi
1.1.1.3 ! root 440: nongcc_SI_type
1.1 root 441: __fixsfsi (a)
442: FLOAT_ARG_TYPE a;
443: {
444: union flt_or_value intify;
445: perform_fixsfsi (FLOATIFY (a));
446: }
447: #endif
448:
449: #ifdef L_floatsidf
450: double
451: __floatsidf (a)
1.1.1.3 ! root 452: nongcc_SI_type a;
1.1 root 453: {
454: perform_floatsidf (a);
455: }
456: #endif
457:
458: #ifdef L_floatsisf
459: FLOAT_VALUE_TYPE
460: __floatsisf (a)
1.1.1.3 ! root 461: nongcc_SI_type a;
1.1 root 462: {
463: union flt_or_value intify;
464: perform_floatsisf (a);
465: }
466: #endif
467:
468: #ifdef L_addsf3
469: FLOAT_VALUE_TYPE
470: __addsf3 (a, b)
471: FLOAT_ARG_TYPE a, b;
472: {
473: union flt_or_value intify;
474: perform_addsf3 (FLOATIFY (a), FLOATIFY (b));
475: }
476: #endif
477:
478: #ifdef L_negsf2
479: FLOAT_VALUE_TYPE
480: __negsf2 (a)
481: FLOAT_ARG_TYPE a;
482: {
483: union flt_or_value intify;
484: perform_negsf2 (FLOATIFY (a));
485: }
486: #endif
487:
488: #ifdef L_subsf3
489: FLOAT_VALUE_TYPE
490: __subsf3 (a, b)
491: FLOAT_ARG_TYPE a, b;
492: {
493: union flt_or_value intify;
494: perform_subsf3 (FLOATIFY (a), FLOATIFY (b));
495: }
496: #endif
497:
498: #ifdef L_eqsf2
1.1.1.3 ! root 499: nongcc_SI_type
1.1 root 500: __eqsf2 (a, b)
501: FLOAT_ARG_TYPE a, b;
502: {
503: union flt_or_int intify;
504: /* Value == 0 iff a == b. */
505: perform_eqsf2 (FLOATIFY (a), FLOATIFY (b));
506: }
507: #endif
508:
509: #ifdef L_nesf2
1.1.1.3 ! root 510: nongcc_SI_type
1.1 root 511: __nesf2 (a, b)
512: FLOAT_ARG_TYPE a, b;
513: {
514: union flt_or_int intify;
515: /* Value != 0 iff a != b. */
516: perform_nesf2 (FLOATIFY (a), FLOATIFY (b));
517: }
518: #endif
519:
520: #ifdef L_gtsf2
1.1.1.3 ! root 521: nongcc_SI_type
1.1 root 522: __gtsf2 (a, b)
523: FLOAT_ARG_TYPE a, b;
524: {
525: union flt_or_int intify;
526: /* Value > 0 iff a > b. */
527: perform_gtsf2 (FLOATIFY (a), FLOATIFY (b));
528: }
529: #endif
530:
531: #ifdef L_gesf2
1.1.1.3 ! root 532: nongcc_SI_type
1.1 root 533: __gesf2 (a, b)
534: FLOAT_ARG_TYPE a, b;
535: {
536: union flt_or_int intify;
537: /* Value >= 0 iff a >= b. */
538: perform_gesf2 (FLOATIFY (a), FLOATIFY (b));
539: }
540: #endif
541:
542: #ifdef L_ltsf2
1.1.1.3 ! root 543: nongcc_SI_type
1.1 root 544: __ltsf2 (a, b)
545: FLOAT_ARG_TYPE a, b;
546: {
547: union flt_or_int intify;
548: /* Value < 0 iff a < b. */
549: perform_ltsf2 (FLOATIFY (a), FLOATIFY (b));
550: }
551: #endif
552:
553: #ifdef L_lesf2
1.1.1.3 ! root 554: nongcc_SI_type
1.1 root 555: __lesf2 (a, b)
556: FLOAT_ARG_TYPE a, b;
557: {
558: union flt_or_int intify;
559: /* Value <= 0 iff a <= b. */
560: perform_lesf2 (FLOATIFY (a), FLOATIFY (b));
561: }
562: #endif
563:
564: #ifdef L_mulsf3
565: FLOAT_VALUE_TYPE
566: __mulsf3 (a, b)
567: FLOAT_ARG_TYPE a, b;
568: {
569: union flt_or_value intify;
570: perform_mulsf3 (FLOATIFY (a), FLOATIFY (b));
571: }
572: #endif
573:
574: #ifdef L_divsf3
575: FLOAT_VALUE_TYPE
576: __divsf3 (a, b)
577: FLOAT_ARG_TYPE a, b;
578: {
579: union flt_or_value intify;
580: perform_divsf3 (FLOATIFY (a), FLOATIFY (b));
581: }
582: #endif
583:
584: #ifdef L_truncdfsf2
585: FLOAT_VALUE_TYPE
586: __truncdfsf2 (a)
587: double a;
588: {
589: union flt_or_value intify;
590: perform_truncdfsf2 (a);
591: }
592: #endif
593:
594: #ifdef L_extendsfdf2
595: double
596: __extendsfdf2 (a)
597: FLOAT_ARG_TYPE a;
598: {
599: union flt_or_value intify;
600: perform_extendsfdf2 (FLOATIFY (a));
601: }
602: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.