![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpgnulib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config / m68k|
Return to fpgnulib.c CVS log | Up to [GCC 2.x] / gcc / config / m68k |
1.1 root 1: /* This is a stripped down version of floatlib.c. It supplies only those
2: functions which exist in libgcc, but for which there is not assembly
3: language versions in m68k/lb1sf68.asm.
4:
5: It also includes simplistic support for extended floats (by working in
6: double precision). You must compile this file again with -DEXTFLOAT
7: to get this support. */
8:
9: /*
10: ** gnulib support for software floating point.
11: ** Copyright (C) 1991 by Pipeline Associates, Inc. All rights reserved.
12: ** Permission is granted to do *anything* you want with this file,
13: ** commercial or otherwise, provided this message remains intact. So there!
14: ** I would appreciate receiving any updates/patches/changes that anyone
15: ** makes, and am willing to be the repository for said changes (am I
16: ** making a big mistake?).
17: **
18: ** Pat Wood
19: ** Pipeline Associates, Inc.
20: ** [email protected] or
21: ** sun!pipeline!phw or
22: ** uunet!motown!pipeline!phw
23: **
24: ** 05/01/91 -- V1.0 -- first release to gcc mailing lists
25: ** 05/04/91 -- V1.1 -- added float and double prototypes and return values
26: ** -- fixed problems with adding and subtracting zero
27: ** -- fixed rounding in truncdfsf2
28: ** -- fixed SWAP define and tested on 386
29: */
30:
31: /*
32: ** The following are routines that replace the gnulib soft floating point
33: ** routines that are called automatically when -msoft-float is selected.
34: ** The support single and double precision IEEE format, with provisions
35: ** for byte-swapped machines (tested on 386). Some of the double-precision
36: ** routines work at full precision, but most of the hard ones simply punt
37: ** and call the single precision routines, producing a loss of accuracy.
38: ** long long support is not assumed or included.
39: ** Overall accuracy is close to IEEE (actually 68882) for single-precision
40: ** arithmetic. I think there may still be a 1 in 1000 chance of a bit
41: ** being rounded the wrong way during a multiply. I'm not fussy enough to
42: ** bother with it, but if anyone is, knock yourself out.
43: **
44: ** Efficiency has only been addressed where it was obvious that something
45: ** would make a big difference. Anyone who wants to do this right for
46: ** best speed should go in and rewrite in assembler.
47: **
48: ** I have tested this only on a 68030 workstation and 386/ix integrated
49: ** in with -msoft-float.
50: */
51:
52: /* the following deal with IEEE single-precision numbers */
53: #define EXCESS 126L
54: #define SIGNBIT 0x80000000L
55: #define HIDDEN (1L << 23L)
56: #define SIGN(fp) ((fp) & SIGNBIT)
57: #define EXP(fp) (((fp) >> 23L) & 0xFF)
58: #define MANT(fp) (((fp) & 0x7FFFFFL) | HIDDEN)
59: #define PACK(s,e,m) ((s) | ((e) << 23L) | (m))
60:
61: /* the following deal with IEEE double-precision numbers */
62: #define EXCESSD 1022
63: #define HIDDEND (1L << 20L)
64: #define EXPDBITS 11
65: #define EXPDMASK 0x7FF
66: #define EXPD(fp) (((fp.l.upper) >> 20L) & 0x7FFL)
67: #define SIGND(fp) ((fp.l.upper) & SIGNBIT)
68: #define MANTD(fp) (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
69: (fp.l.lower >> 22))
70: #define MANTDMASK 0xFFFFF /* mask of upper part */
71:
72: /* the following deal with IEEE extended-precision numbers */
73: #define EXCESSX 16382
74: #define HIDDENX (1L << 31L)
75: #define EXPXBITS 15
76: #define EXPXMASK 0x7FFF
77: #define EXPX(fp) (((fp.l.upper) >> 16) & EXPXMASK)
78: #define SIGNX(fp) ((fp.l.upper) & SIGNBIT)
79: #define MANTXMASK 0x7FFFFFFF /* mask of upper part */
80:
81: union double_long
82: {
83: double d;
84: struct {
85: long upper;
86: unsigned long lower;
87: } l;
88: };
89:
90: union float_long {
91: float f;
92: long l;
93: };
94:
95: union long_double_long
96: {
97: long double ld;
98: struct
99: {
100: long upper;
101: unsigned long middle;
102: unsigned long lower;
103: } l;
104: };
105:
106: #ifndef EXTFLOAT
107:
108: /* convert int to double */
109: double
110: __floatsidf (int a1)
111: {
112: long sign = 0, exp = 31 + EXCESSD;
113: union double_long dl;
114:
115: if (!a1)
116: {
117: dl.l.upper = dl.l.lower = 0;
118: return dl.d;
119: }
120:
121: if (a1 < 0)
122: {
123: sign = SIGNBIT;
124: a1 = -a1;
125: if (a1 < 0)
126: {
127: dl.l.upper = SIGNBIT | ((32 + EXCESSD) << 20L);
128: dl.l.lower = 0;
129: return dl.d;
130: }
131: }
132:
133: while (a1 < 0x1000000)
134: {
135: a1 <<= 4;
136: exp -= 4;
137: }
138:
139: while (a1 < 0x40000000)
140: {
141: a1 <<= 1;
142: exp--;
143: }
144:
145: /* pack up and go home */
146: dl.l.upper = sign;
147: dl.l.upper |= exp << 20L;
148: dl.l.upper |= (a1 >> 10L) & ~HIDDEND;
149: dl.l.lower = a1 << 22L;
150:
151: return dl.d;
152: }
153:
154: /* convert int to float */
155: float
156: __floatsisf (int l)
157: {
158: double foo = __floatsidf (l);
159: return foo;
160: }
161:
162: /* convert float to double */
163: double
164: __extendsfdf2 (float a1)
165: {
166: register union float_long fl1;
167: register union double_long dl;
168: register long exp;
169:
170: fl1.f = a1;
171:
172: if (!fl1.l)
173: {
174: dl.l.upper = dl.l.lower = 0;
175: return dl.d;
176: }
177:
178: dl.l.upper = SIGN (fl1.l);
179: exp = EXP (fl1.l) - EXCESS + EXCESSD;
180: dl.l.upper |= exp << 20;
181: dl.l.upper |= (MANT (fl1.l) & ~HIDDEN) >> 3;
182: dl.l.lower = MANT (fl1.l) << 29;
183:
184: return dl.d;
185: }
186:
187: /* convert double to float */
188: float
189: __truncdfsf2 (double a1)
190: {
191: register long exp;
192: register long mant;
193: register union float_long fl;
194: register union double_long dl1;
195:
196: dl1.d = a1;
197:
198: if (!dl1.l.upper && !dl1.l.lower)
199: return 0;
200:
201: exp = EXPD (dl1) - EXCESSD + EXCESS;
202:
203: /* shift double mantissa 6 bits so we can round */
204: mant = MANTD (dl1) >> 6;
205:
206: /* now round and shift down */
207: mant += 1;
208: mant >>= 1;
209:
210: /* did the round overflow? */
211: if (mant & 0xFF000000)
212: {
213: mant >>= 1;
214: exp++;
215: }
216:
217: mant &= ~HIDDEN;
218:
219: /* pack up and go home */
220: fl.l = PACK (SIGND (dl1), exp, mant);
221: return (fl.f);
222: }
223:
224: /* convert double to int */
225: int
226: __fixdfsi (double a1)
227: {
228: register union double_long dl1;
229: register long exp;
230: register long l;
231:
232: dl1.d = a1;
233:
234: if (!dl1.l.upper && !dl1.l.lower)
235: return 0;
236:
237: exp = EXPD (dl1) - EXCESSD - 31;
238: l = MANTD (dl1);
239:
240: if (exp > 0)
241: {
242: /* Return largest integer. */
243: return SIGND (dl1) ? 0x80000000 : 0x7fffffff;
244: }
245:
246: if (exp <= -32)
247: return 0;
248:
249: /* shift down until exp = 0 */
250: if (exp < 0)
251: l >>= -exp;
252:
253: return (SIGND (dl1) ? -l : l);
254: }
255:
256: /* convert float to int */
257: int
258: __fixsfsi (float a1)
259: {
260: double foo = a1;
261: return __fixdfsi (foo);
262: }
263:
264: #else /* EXTFLOAT */
265:
266: /* Primitive extended precision floating point support.
267:
268: We assume all numbers are normalized, don't do any rounding, etc. */
269:
270: /* Prototypes for the above in case we use them. */
271: double __floatsidf (int);
272: float __floatsisf (int);
273: double __extendsfdf2 (float);
274: float __truncdfsf2 (double);
275: int __fixdfsi (double);
276: int __fixsfsi (float);
277:
278: /* convert double to long double */
279: long double
280: __extenddfxf2 (double d)
281: {
282: register union double_long dl;
283: register union long_double_long ldl;
284: register long exp;
285:
286: dl.d = d;
287: /*printf ("dfxf in: %g\n", d);*/
288:
289: if (!dl.l.upper && !dl.l.lower)
290: return 0;
291:
292: ldl.l.upper = SIGND (dl);
293: exp = EXPD (dl) - EXCESSD + EXCESSX;
294: ldl.l.upper |= exp << 16;
295: ldl.l.middle = HIDDENX;
296: /* 31-20: # mantissa bits in ldl.l.middle - # mantissa bits in dl.l.upper */
297: ldl.l.middle |= (dl.l.upper & MANTDMASK) << (31 - 20);
298: /* 1+20: explicit-integer-bit + # mantissa bits in dl.l.upper */
299: ldl.l.middle |= dl.l.lower >> (1 + 20);
300: /* 32 - 21: # bits of dl.l.lower in ldl.l.middle */
301: ldl.l.lower = dl.l.lower << (32 - 21);
302:
303: /*printf ("dfxf out: %s\n", dumpxf (ldl.ld));*/
304: return ldl.ld;
305: }
306:
307: /* convert long double to double */
308: double
309: __truncxfdf2 (long double ld)
310: {
311: register long exp;
312: register union double_long dl;
313: register union long_double_long ldl;
314:
315: ldl.ld = ld;
316: /*printf ("xfdf in: %s\n", dumpxf (ld));*/
317:
318: if (!ldl.l.upper && !ldl.l.middle && !ldl.l.lower)
319: return 0;
320:
321: exp = EXPX (ldl) - EXCESSX + EXCESSD;
322: /* ??? quick and dirty: keep `exp' sane */
323: if (exp >= EXPDMASK)
324: exp = EXPDMASK - 1;
325: dl.l.upper = SIGNX (ldl);
326: dl.l.upper |= exp << (32 - (EXPDBITS + 1));
327: /* +1-1: add one for sign bit, but take one off for explicit-integer-bit */
328: dl.l.upper |= (ldl.l.middle & MANTXMASK) >> (EXPDBITS + 1 - 1);
329: dl.l.lower = (ldl.l.middle & MANTXMASK) << (32 - (EXPDBITS + 1 - 1));
330: dl.l.lower |= ldl.l.lower >> (EXPDBITS + 1 - 1);
331:
332: /*printf ("xfdf out: %g\n", dl.d);*/
333: return dl.d;
334: }
335:
336: /* convert a float to a long double */
337: long double
338: __extendsfxf2 (float f)
339: {
340: long double foo = __extenddfxf2 (__extendsfdf2 (f));
341: return foo;
342: }
343:
344: /* convert a long double to a float */
345: float
346: __truncxfsf2 (long double ld)
347: {
348: float foo = __truncdfsf2 (__truncxfdf2 (ld));
349: return foo;
350: }
351:
352: /* convert an int to a long double */
353: long double
354: __floatsixf (int l)
355: {
356: double foo = __floatsidf (l);
357: return foo;
358: }
359:
360: /* convert a long double to an int */
361: int
362: __fixxfsi (long double ld)
363: {
364: int foo = __fixdfsi ((double) ld);
365: return foo;
366: }
367:
368: /* The remaining provide crude math support by working in double precision. */
369:
370: long double
371: __addxf3 (long double x1, long double x2)
372: {
373: return (double) x1 + (double) x2;
374: }
375:
376: long double
377: __subxf3 (long double x1, long double x2)
378: {
379: return (double) x1 - (double) x2;
380: }
381:
382: long double
383: __mulxf3 (long double x1, long double x2)
384: {
385: return (double) x1 * (double) x2;
386: }
387:
388: long double
389: __divxf3 (long double x1, long double x2)
390: {
391: return (double) x1 / (double) x2;
392: }
393:
394: long double
395: __negxf2 (long double x1)
396: {
397: return - (double) x1;
398: }
399:
400: long
401: __cmpxf2 (long double x1, long double x2)
402: {
403: return __cmpdf2 ((double) x1, (double) x2);
404: }
405:
406: long
407: __eqxf2 (long double x1, long double x2)
408: {
409: return __cmpdf2 ((double) x1, (double) x2);
410: }
411:
412: long
413: __nexf2 (long double x1, long double x2)
414: {
415: return __cmpdf2 ((double) x1, (double) x2);
416: }
417:
418: long
419: __ltxf2 (long double x1, long double x2)
420: {
421: return __cmpdf2 ((double) x1, (double) x2);
422: }
423:
424: long
425: __lexf2 (long double x1, long double x2)
426: {
427: return __cmpdf2 ((double) x1, (double) x2);
428: }
429:
430: long
431: __gtxf2 (long double x1, long double x2)
432: {
433: return __cmpdf2 ((double) x1, (double) x2);
434: }
435:
436: long
437: __gexf2 (long double x1, long double x2)
438: {
439: return __cmpdf2 ((double) x1, (double) x2);
440: }
441:
442: #endif /* EXTFLOAT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.