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