![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ieee754-misc-auto.sh CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic / ieee754|
Return to ieee754-misc-auto.sh CVS log | Up to [The Machine Emulator] / tme / ic / ieee754 |
1.1 root 1: #! /bin/sh
2:
3: # $Id: ieee754-misc-auto.sh,v 1.2 2005/05/11 00:13:33 fredette Exp $
4:
5: # ic/ieee754/ieee754-misc-auto.sh - automatically generates C code
6: # for miscellaneous IEEE 754 emulation support:
7:
8: #
9: # Copyright (c) 2004 Matt Fredette
10: # All rights reserved.
11: #
12: # Redistribution and use in source and binary forms, with or without
13: # modification, are permitted provided that the following conditions
14: # are met:
15: # 1. Redistributions of source code must retain the above copyright
16: # notice, this list of conditions and the following disclaimer.
17: # 2. Redistributions in binary form must reproduce the above copyright
18: # notice, this list of conditions and the following disclaimer in the
19: # documentation and/or other materials provided with the distribution.
20: # 3. All advertising materials mentioning features or use of this software
21: # must display the following acknowledgement:
22: # This product includes software developed by Matt Fredette.
23: # 4. The name of the author may not be used to endorse or promote products
24: # derived from this software without specific prior written permission.
25: #
26: # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27: # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28: # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29: # DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
30: # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
31: # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
32: # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
34: # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
35: # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: # POSSIBILITY OF SUCH DAMAGE.
37: #
38:
39: header=false
40:
41: for option
42: do
43: case $option in
44: --header) header=true ;;
45: esac
46: done
47:
48: PROG=`basename $0`
49: cat <<EOF
50: /* automatically generated by $PROG, do not edit! */
51: #include <tme/common.h>
52: _TME_RCSID("\$Id: ieee754-misc-auto.sh,v 1.2 2005/05/11 00:13:33 fredette Exp $");
53:
54: EOF
55: if $header; then
56: :
57: else
58: cat <<EOF
59: #include <tme/ic/ieee754.h>
60: #include "softfloat-tme.h"
61: #include <math.h>
62: #ifdef HAVE_FLOAT_H
63: #include <float.h>
64: #endif
65: #ifdef HAVE_LIMITS_H
66: #include <limits.h>
67: #endif
68: EOF
69: fi
70:
71: # permute for the different precisions we want to support:
72: #
73: for precision in single double extended80 quad; do
74:
75: # get information about this precision:
76: #
77: _precision=`echo $0 | sed -e "s/$PROG/ieee754-precision.sh/"`
78: eval `sh ${_precision} ${precision}`
79:
80: # if we're generating a header:
81: #
82: if $header; then
83: cat <<EOF
84:
85: /* decide which builtin C floating-point type is the best match for
86: the IEEE 754 ${precision} precision format. if a builtin type matches
87: this format exactly, use that type, otherwise we assume that the
88: smallest builtin type that is at least ${size} bytes wide is the best
89: match. if no builtin type is at least that wide, we use long
90: double, or double if long double is not available: */
91: #if ((TME_FLOAT_FORMATS_BUILTIN & TME_FLOAT_FORMAT_IEEE754_${capprecision}) != 0)
92: #define TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN TME_FLOAT_FORMAT_IEEE754_${capprecision}
93: #elif (_TME_SIZEOF_FLOAT >= ${size})
94: #define TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN TME_FLOAT_FORMAT_FLOAT
95: #elif (_TME_SIZEOF_DOUBLE >= ${size} || !defined(_TME_HAVE_LONG_DOUBLE))
96: #define TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN TME_FLOAT_FORMAT_DOUBLE
97: #else
98: #define TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN TME_FLOAT_FORMAT_LONG_DOUBLE
99: #endif
100:
101: /* typedef the builtin C floating-point type that is the best match
102: for the IEEE 754 ${precision} precision format: */
103: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
104: typedef float tme_ieee754_${precision}_builtin_t;
105: #define tme_float_value_ieee754_${precision}_builtin tme_float_value_float
106: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
107: typedef double tme_ieee754_${precision}_builtin_t;
108: #define tme_float_value_ieee754_${precision}_builtin tme_float_value_double
109: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE)
110: typedef long double tme_ieee754_${precision}_builtin_t;
111: #define tme_float_value_ieee754_${precision}_builtin tme_float_value_long_double
112: #endif
113:
114: /* this asserts that the float is either in IEEE 754 ${precision}
115: precision format, or in the best-match builtin type format. it
116: evaluates to nonzero if the float is in IEEE 754 ${precision}
117: precision format: */
118: #define tme_ieee754_${precision}_is_format(x) \\
119: (tme_float_assert_formats(x, \\
120: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) \\
121: && tme_float_is_format(x, \\
122: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN, \\
123: TME_FLOAT_FORMAT_IEEE754_${capprecision}))
124:
125: /* this asserts that the float is either in IEEE 754 ${precision}
126: precision format, or in the best-match builtin type format. it
127: evaluates to nonzero if the float is in the best-match builtin
128: type format: */
129: #define tme_ieee754_${precision}_is_format_builtin(x) \\
130: (tme_float_assert_formats(x, \\
131: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) \\
132: && tme_float_is_format(x, \\
133: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN, \\
134: TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN))
135:
136: /* this asserts that the float is either in IEEE 754 ${precision}
137: precision format, or in the best-match builtin type format. it
138: evaluates to nonzero if the float is a NaN: */
139: #define tme_ieee754_${precision}_is_nan(x) \\
140: (tme_float_assert_formats(x, \\
141: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) \\
142: && tme_float_is_nan(x, \\
143: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN))
144:
145: /* this asserts that the float is either in IEEE 754 ${precision}
146: precision format, or in the best-match builtin type format. it
147: evaluates to nonzero if the float is an infinity: */
148: #define tme_ieee754_${precision}_is_inf(x) \\
149: (tme_float_assert_formats(x, \\
150: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) \\
151: && tme_float_is_inf(x, \\
152: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN))
153:
154: /* this asserts that the float is either in IEEE 754 ${precision}
155: precision format, or in the best-match builtin type format. it
156: evaluates to nonzero if the float is a zero: */
157: #define tme_ieee754_${precision}_is_zero(x) \\
158: (tme_float_assert_formats(x, \\
159: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) \\
160: && tme_float_is_zero(x, \\
161: TME_FLOAT_FORMAT_IEEE754_${capprecision} | TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN))
162:
163: /* tme_ieee754_${precision}_value_get(x, buffer) returns a pointer to
164: the value of x in IEEE 754 ${precision} precision format (i.e., it
165: returns a pointer to ${integral}). if x isn't already in this
166: format, it is converted into that format in the given buffer: */
167: #define tme_ieee754_${precision}_value_get(x, buffer) \\
168: (tme_ieee754_${precision}_is_format(x) \\
169: ? &(x)->tme_float_value_ieee754_${precision} \\
170: : tme_ieee754_${precision}_value_from_builtin((x)->tme_float_value_ieee754_${precision}_builtin, buffer))
171:
172: /* tme_ieee754_${precision}_value_set(x, y) sets the value of x to
173: y, in IEEE 754 ${precision} precision format (i.e., y is a ${integral}).
174: (the internal function _tme_ieee754_${precision}_value_set(x, t, y)
175: takes the type of y, which must be compatible with ${integral}): */
176: #define tme_ieee754_${precision}_value_set(x, y) \\
177: do { \\
178: (x)->tme_float_value_ieee754_${precision} = (y); \\
179: (x)->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision}; \\
180: } while (/* CONSTCOND */ 0)
181: #define _tme_ieee754_${precision}_value_set(x, t, y) \\
182: do { \\
183: *((t *) &(x)->tme_float_value_ieee754_${precision}) = (y); \\
184: (x)->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision}; \\
185: } while (/* CONSTCOND */ 0)
186:
187: /* tme_ieee754_${precision}_value_set_constant(x, y) sets the value of
188: x to the constant y (i.e., y is a const ${constant} *): */
189: #define tme_ieee754_${precision}_value_set_constant(x, y) \\
190: do { \\
191: EOF
192: x_value="(x)->tme_float_value_ieee754_${precision}"
193: case "${precision}" in
194: single)
195: echo " ${x_value} = *(y); \\"
196: ;;
197: double)
198: echo " ${x_value}.tme_value64_uint32_hi = (y)->tme_ieee754_double_constant_hi; \\"
199: echo " ${x_value}.tme_value64_uint32_lo = (y)->tme_ieee754_double_constant_lo; \\"
200: ;;
201: extended80)
202: echo " ${x_value}.tme_float_ieee754_extended80_sexp = (y)->tme_ieee754_extended80_constant_sexp; \\"
203: echo " ${x_value}.tme_float_ieee754_extended80_significand.tme_value64_uint32_hi = (y)->tme_ieee754_extended80_constant_significand_hi; \\"
204: echo " ${x_value}.tme_float_ieee754_extended80_significand.tme_value64_uint32_lo = (y)->tme_ieee754_extended80_constant_significand_lo; \\"
205: ;;
206: quad)
207: echo " ${x_value}.tme_float_ieee754_quad_hi.tme_value64_uint32_hi = (y)->tme_ieee754_quad_constant_hi_hi; \\"
208: echo " ${x_value}.tme_float_ieee754_quad_hi.tme_value64_uint32_lo = (y)->tme_ieee754_quad_constant_hi_lo; \\"
209: echo " ${x_value}.tme_float_ieee754_quad_lo.tme_value64_uint32_hi = (y)->tme_ieee754_quad_constant_lo_hi; \\"
210: echo " ${x_value}.tme_float_ieee754_quad_lo.tme_value64_uint32_lo = (y)->tme_ieee754_quad_constant_lo_lo; \\"
211: ;;
212: esac
213: cat <<EOF
214: (x)->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision}; \\
215: } while (/* CONSTCOND */ 0)
216:
217: /* tme_ieee754_${precision}_value_builtin_get(x) returns the value of
218: x as the builtin C type that is the best match for the IEEE 754
219: ${precision} precision format: */
220: #define tme_ieee754_${precision}_value_builtin_get(x) \\
221: (tme_ieee754_${precision}_is_format_builtin(x) \\
222: ? (x)->tme_float_value_ieee754_${precision}_builtin \\
223: : tme_ieee754_${precision}_value_to_builtin(&(x)->tme_float_value_ieee754_${precision}))
224:
225: /* tme_ieee754_${precision}_value_builtin_set(x, format, y) sets the value of
226: x to y, whose type is a builtin C type with format format. if the value of
227: y is a NaN or an infinity, y is stored in x in IEEE 754 ${precision}
228: precision format, otherwise y is stored in x as the builtin C type
229: that is the best match for the IEEE 754 ${precision} precision format: */
230: #define tme_ieee754_${precision}_value_builtin_set(x, format, y) \\
231: do { \\
232: /* set the value: */ \\
233: tme_float_value_builtin_set(x, format, y); \\
234: \\
235: /* if the result is a NaN: */ \\
236: if (tme_float_is_nan(x, format)) { \\
237: \\
238: /* use the proper default IEEE 754 ${precision} precision NaN: */ \\
239: (x)->tme_float_value_ieee754_${precision} = ieee754_ctl->tme_ieee754_ctl_default_nan_${precision}; \\
240: (x)->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision}; \\
241: } \\
242: \\
243: /* otherwise, if the result isn't already in IEEE 754 ${precision} precision format: */ \\
244: else if ((format) != TME_FLOAT_FORMAT_IEEE754_${capprecision}) { \\
245: \\
246: /* if the result is infinite: */ \\
247: if (tme_float_is_inf(x, format)) { \\
248: \\
249: /* use the IEEE 754 ${precision} precision infinity: */ \\
250: (x)->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision}; \\
251: (x)->tme_float_value_ieee754_${precision}${sexp} = ${mask_exp} | (tme_float_is_negative(x, (format)) ? ${mask_sign} : 0); \\
252: EOF
253: case "${precision}" in
254: single) ;;
255: double)
256: echo " (x)->tme_float_value_ieee754_double.tme_value64_uint32_lo = 0; \\"
257: ;;
258: extended80)
259: echo " (x)->tme_float_value_ieee754_extended80.tme_float_ieee754_extended80_significand.tme_value64_uint32_hi = 0; \\"
260: echo " (x)->tme_float_value_ieee754_extended80.tme_float_ieee754_extended80_significand.tme_value64_uint32_lo = 0; \\"
261: ;;
262: quad)
263: echo " (x)->tme_float_value_ieee754_quad.tme_float_ieee754_quad_hi.tme_value64_uint32_lo = 0; \\"
264: echo " (x)->tme_float_value_ieee754_quad.tme_float_ieee754_quad_lo.tme_value64_uint32_hi = 0; \\"
265: echo " (x)->tme_float_value_ieee754_quad.tme_float_ieee754_quad_lo.tme_value64_uint32_lo = 0; \\"
266: ;;
267: esac
268: cat <<EOF
269: } \\
270: \\
271: /* otherwise, if the result isn't already the builtin C type that \\
272: is the best match for the IEEE 754 ${precision} precision format: */ \\
273: else if ((format) != TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN) { \\
274: \\
275: /* convert the result: */ \\
276: if ((format) == TME_FLOAT_FORMAT_FLOAT) { \\
277: (x)->tme_float_value_ieee754_${precision}_builtin = (x)->tme_float_value_float; \\
278: } \\
279: TME_FLOAT_IF_LONG_DOUBLE(else if ((format) == TME_FLOAT_FORMAT_LONG_DOUBLE) { \\
280: (x)->tme_float_value_ieee754_${precision}_builtin = (x)->tme_float_value_long_double; \\
281: }) \\
282: else { \\
283: assert((format) == TME_FLOAT_FORMAT_DOUBLE); \\
284: (x)->tme_float_value_ieee754_${precision}_builtin = (x)->tme_float_value_double; \\
285: } \\
286: } \\
287: } \\
288: } while (/* CONSTCOND */ 0)
289:
290: /* this converts a value from IEEE 754 ${precision} precision format
291: into the builtin C type that is the best match for that format: */
292: tme_ieee754_${precision}_builtin_t tme_ieee754_${precision}_value_to_builtin _TME_P((const ${integral} *));
293:
294: /* this converts a value from the builtin C type that is the best
295: match for the IEEE 754 ${precision} precision format, into that
296: format: */
297: const ${integral} *tme_ieee754_${precision}_value_from_builtin _TME_P((tme_ieee754_${precision}_builtin_t, ${integral} *));
298:
299: /* this does a NaN check for an IEEE 754 ${precision} precision monadic function: */
300: int tme_ieee754_${precision}_check_nan_monadic _TME_P((struct tme_ieee754_ctl *, const struct tme_float *, struct tme_float *));
301:
302: /* this does a NaN check for an IEEE 754 ${precision} precision dyadic function: */
303: int tme_ieee754_${precision}_check_nan_dyadic _TME_P((struct tme_ieee754_ctl *, const struct tme_float *, const struct tme_float *, struct tme_float *));
304: EOF
305:
306: # emit the prototypes for the from-integer conversion
307: # functions:
308: #
309: for convert in int32 int64; do
310:
311: cond=1
312: case ${convert} in
313: int32) convert_builtin="tme_uint32_t" ;;
314: int64) convert_builtin="tme_uint64_t" ; cond="defined(TME_HAVE_INT64_T)" ;;
315: esac
316:
317: if test "${cond}" != 1; then
318: echo ""
319: echo "#if ${cond}"
320: fi
321:
322: echo ""
323: echo "/* this converts a ${convert_builtin} to a ${precision}: */"
324: echo "void tme_ieee754_${precision}_from_${convert} _TME_P((${convert_builtin}, struct tme_float *));"
325:
326: if test "${cond}" != 1; then
327: echo ""
328: echo "#endif /* ${cond} */"
329: fi
330: done
331:
332: # permute over the radices:
333: #
334: for radix in 10; do
335:
336: cat <<EOF
337:
338: /* this converts an in-range IEEE 754 ${precision} precision value into its
339: radix ${radix} mantissa and exponent. the mantissa is either zero, or
340: in the range [1,${radix}): */
341: void tme_ieee754_${precision}_radix${radix}_mantissa_exponent _TME_P((struct tme_ieee754_ctl *, const struct tme_float *, struct tme_float *, struct tme_float *));
342:
343: /* this scales an IEEE 754 ${precision} precision value by adding n to its
344: radix ${radix} exponent: */
345: void tme_ieee754_${precision}_radix${radix}_scale _TME_P((struct tme_ieee754_ctl *, const struct tme_float *, const struct tme_float *, struct tme_float *));
346:
347: EOF
348: done
349:
350: # otherwise, we're not generating a header:
351: #
352: else
353:
354: cat <<EOF
355:
356: /* this converts a value from IEEE 754 ${precision} precision format
357: to the builtin C type that is the best match for that format: */
358: tme_ieee754_${precision}_builtin_t
359: tme_ieee754_${precision}_value_to_builtin(const ${integral} *x_ieee754)
360: {
361: tme_ieee754_${precision}_builtin_t x_builtin;
362: tme_uint32_t exponent;
363: tme_uint32_t sign;
364: tme_uint32_t chunk;
365: tme_uint32_t fracor;
366:
367: /* get x's biased exponent: */
368: exponent = TME_FIELD_MASK_EXTRACTU((*x_ieee754)${sexp}, ${mask_exp});
369:
370: /* convert the fraction one 16-bit chunk at a time, and track
371: a bitwise-or of all of the fraction bits: */
372: EOF
373: chunk_i=0
374: while true; do
375: eval "chunk_member=\$chunk_member_${chunk_i} ; chunk_mask=\$chunk_mask_${chunk_i}"
376: if test "x${chunk_member}" = xx; then
377: break
378: fi
379: echo " chunk = TME_FIELD_MASK_EXTRACTU((*x_ieee754)${chunk_member}, ${chunk_mask});"
380: if test ${chunk_i} = 0; then
381: echo " fracor = chunk;"
382: if ${implicit}; then
383: echo " /* if the exponent is nonzero, add the implicit integer bit: */"
384: echo " if (exponent != 0) chunk |= ((${chunk_mask} / _TME_FIELD_MASK_FACTOR(${chunk_mask})) + 1);"
385: fi
386: echo " x_builtin = chunk;"
387: else
388: echo " fracor |= chunk;"
389: echo " x_builtin = (x_builtin * 65536) + chunk;"
390: fi
391: chunk_i=`expr ${chunk_i} + 1`
392: done
393: cat <<EOF
394:
395: /* get x's sign bit: */
396: sign = ((*x_ieee754)${sexp} & ${mask_sign});
397:
398: /* if the exponent is the biased maximum, x is either an infinity or a NaN: */
399: if (exponent == ${exp_biased_max}) {
400:
401: /* if the fraction is nonzero, x is a NaN. x must not be a NaN,
402: because we were supposed to catch this earlier: */
403: assert (fracor == 0);
404:
405: /* x is an infinity. construct a builtin infinity: */
406: /* XXX FIXME - we assume that multiplying the maximum builtin
407: value by +10 or -10 will not yield a value whose magnitude is
408: less than the maximum builtin value: */
409: x_builtin =
410: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
411: FLOAT_MAX_FLOAT
412: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
413: FLOAT_MAX_DOUBLE
414: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
415: FLOAT_MAX_LONG_DOUBLE
416: #endif
417: * (sign ? -10 : 10);
418: }
419:
420: /* if the exponent is the biased minimum and the fraction is
421: all-bits-zero, x is a zero: */
422: else if (exponent == 0
423: && fracor == 0) {
424:
425: /* construct a builtin zero: */
426: /* XXX FIXME - we assume that dividing the minimum builtin value
427: by +10 or -10 (in case the builtin type is radix 10) will yield
428: a value whose magnitude is not greater than the minimum builtin
429: value: */
430: x_builtin =
431: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
432: FLOAT_MIN_FLOAT
433: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
434: FLOAT_MIN_DOUBLE
435: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
436: FLOAT_MIN_LONG_DOUBLE
437: #endif
438: / (sign ? -10 : 10);
439: }
440:
441: /* otherwise, x is an in-range value that needs to be converted: */
442: else {
443:
444: /* scale the result by the unbiased exponent, adjusted by the
445: number of fraction bits (which are currently to the left of the
446: floating point in x_builtin): */
447: x_builtin =
448: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
449: tme_float_radix2_scale_float
450: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
451: tme_float_radix2_scale_double
452: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
453: tme_float_radix2_scale_long_double
454: #endif
455: (x_builtin, (exponent - ${exp_bias}) - ${fracbits});
456:
457: if (sign) {
458: x_builtin = 0 - x_builtin;
459: }
460: }
461:
462: /* done: */
463: return (x_builtin);
464: }
465:
466: /* this converts a value from the builtin C type that is the best
467: match for the IEEE 754 ${precision} precision format, to that
468: format: */
469: const ${integral} *
470: tme_ieee754_${precision}_value_from_builtin(tme_ieee754_${precision}_builtin_t x_builtin, ${integral} *x_ieee754)
471: {
472: tme_int32_t exponent;
473: tme_uint32_t chunk;
474:
475: /* x must not be a NaN or an infinity: */
476: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
477: assert (!isnanf(x_builtin));
478: assert (!isinff(x_builtin));
479: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
480: assert (!isnan(x_builtin));
481: assert (!isinf(x_builtin));
482: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
483: assert (!isnan(x_builtin));
484: assert (!isinf(x_builtin));
485: #endif
486:
487: /* get the mantissa and exponent of x: */
488: x_builtin =
489: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
490: tme_float_radix2_mantissa_exponent_float
491: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
492: tme_float_radix2_mantissa_exponent_double
493: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
494: tme_float_radix2_mantissa_exponent_long_double
495: #endif
496: (x_builtin, &exponent);
497:
498: /* zero the IEEE 754 version: */
499: memset((char *) x_ieee754, 0, sizeof((*x_ieee754)));
500:
501: /* set x's sign bit: */
502: if (x_builtin < 0) {
503: (*x_ieee754)${sexp} |= ${mask_sign};
504: x_builtin = -x_builtin;
505: }
506:
507: /* if x is zero, return now: */
508: if (x_builtin == 0) {
509: return (x_ieee754);
510: }
511:
512: /* bias the exponent: */
513: exponent += ${exp_bias};
514:
515: /* if the biased exponent is greater than or equal to the biased
516: maximum, we must represent x as an infinity: */
517: if (exponent >= (tme_int32_t) ${exp_biased_max}) {
518:
519: /* we do this by just setting the biased exponent to the biased
520: maximum: */
521: exponent = ${exp_biased_max};
522: }
523:
524: /* otherwise, x will be either a normalized number, a denormalized
525: number, or possibly a zero: */
526: else {
527:
528: /* if the biased exponent is less than or equal to the biased
529: minimum, x will be a denormalized number (possibly so
530: denormalized that it becomes a zero): */
531: if (exponent <= 0) {
532:
533: /* scale x into a denormalized number: */
534: assert (x_builtin >= 1);
535: x_builtin =
536: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)
537: tme_float_radix2_scale_float
538: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_DOUBLE)
539: tme_float_radix2_scale_double
540: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_LONG_DOUBLE))
541: tme_float_radix2_scale_long_double
542: #endif
543: (x_builtin, exponent - 1);
544: assert (x_builtin < 1);
545: exponent = 0;
546: }
547:
548: /* convert the mantissa, one 16-bit chunk at a time: */
549: EOF
550: chunk_i=0
551: while true; do
552: eval "chunk_member=\$chunk_member_${chunk_i} ; chunk_mask=\$chunk_mask_${chunk_i}"
553: if test "x${chunk_member}" = xx; then
554: break
555: fi
556: factor="((${chunk_mask} / _TME_FIELD_MASK_FACTOR(${chunk_mask})) + 1)"
557: if test ${chunk_i} = 0; then
558: if ${implicit}; then
559: echo " /* remove any implicit integer bit: */"
560: echo " if (x_builtin >= 1) {"
561: echo " x_builtin -= 1;"
562: echo " }"
563: else
564: factor="(${factor} / 2)"
565: fi
566: fi
567: echo " x_builtin = x_builtin * ${factor};"
568: echo " chunk = x_builtin;"
569: echo " x_builtin -= chunk;"
570: echo " TME_FIELD_MASK_DEPOSITU((*x_ieee754)${chunk_member}, ${chunk_mask}, chunk);"
571: chunk_i=`expr ${chunk_i} + 1`
572: factor=65536
573: done
574: cat <<EOF
575: }
576:
577: /* set x's biased exponent: */
578: TME_FIELD_MASK_DEPOSITU((*x_ieee754)${sexp}, ${mask_exp}, exponent);
579:
580: /* done: */
581: return (x_ieee754);
582: }
583: EOF
584:
585: # emit the NaN check functions:
586: #
587: for monadic in true false; do
588: if ${monadic}; then type=monadic; else type=dyadic; fi
589:
590: echo ""
591: echo "/* this does a NaN check for an IEEE 754 ${precision} precision ${type} function: */"
592: echo "int"
593: echo -n "tme_ieee754_${precision}_check_nan_${type}(struct tme_ieee754_ctl *ieee754_ctl, const struct tme_float *src0"
594: if ${monadic}; then :; else
595: echo -n ", const struct tme_float *src1"
596: fi
597: echo ", struct tme_float *dst)"
598: echo "{"
599: echo " const ${integral} *nan0;"
600: if $monadic; then :; else
601: echo " const ${integral} *nan1;"
602: fi
603: echo ""
604: echo " /* check for a NaN operand: */"
605: echo " nan0 = NULL;"
606: echo " if (tme_ieee754_${precision}_is_nan(src0)) {"
607: echo " assert (src0->tme_float_format == TME_FLOAT_FORMAT_IEEE754_${capprecision});"
608: echo " nan0 = &src0->tme_float_value_ieee754_${precision};"
609: echo " }"
610: if $monadic; then nan1=nan0; else
611: nan1=nan1
612: echo " nan1 = nan0;"
613: echo " if (tme_ieee754_${precision}_is_nan(src1)) {"
614: echo " assert (src1->tme_float_format == TME_FLOAT_FORMAT_IEEE754_${capprecision});"
615: echo " nan1 = &src1->tme_float_value_ieee754_${precision};"
616: echo " if (nan0 == NULL) {"
617: echo " nan0 = nan1;"
618: echo " }"
619: echo " }"
620: fi
621: echo ""
622: echo " /* if we have a NaN operand: */"
623: echo " if (__tme_predict_false(nan0 != NULL)) {"
624: echo ""
625: echo " /* propagate a NaN: */"
626: echo " dst->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision};"
627: echo " (*ieee754_ctl->tme_ieee754_ctl_nan_from_nans_${precision})"
628: echo " (ieee754_ctl, nan0, ${nan1}, &dst->tme_float_value_ieee754_${precision});"
629: echo " return (TRUE);"
630: echo " }"
631: echo ""
632: echo " return (FALSE);"
633: echo "}"
634: done
635:
636: # emit the from-integer conversion functions:
637: #
638: for convert in int32 int64; do
639:
640: cond=1
641: case ${convert} in
642: int32) convert_builtin="tme_uint32_t" ;;
643: int64) convert_builtin="tme_uint64_t" ; cond="defined(TME_HAVE_INT64_T)" ;;
644: esac
645:
646: if test "${cond}" != 1; then
647: echo ""
648: echo "#if ${cond}"
649: fi
650:
651: echo ""
652: echo "/* this converts a ${convert_builtin} to a ${precision}: */"
653: echo "void"
654: echo "tme_ieee754_${precision}_from_${convert}(${convert_builtin} src, struct tme_float *dst)"
655: echo "{"
656: echo " _tme_ieee754_${precision}_value_set(dst, ${precision_sf}, ${convert}_to_${precision_sf}(src));"
657: echo "}"
658:
659: if test "${cond}" != 1; then
660: echo ""
661: echo "#endif /* ${cond} */"
662: fi
663: done
664:
665: echo ""
666: echo "/* this converts a ${precision} to an int32: */"
667: echo "tme_int32_t"
668: echo "tme_ieee754_${precision}_to_int32(const struct tme_float *src)"
669: echo "{"
670: echo " ${integral} src_buffer;"
671: echo " return (${precision_sf}_to_int32(*((const ${precision_sf} *) tme_ieee754_${precision}_value_get(src, &src_buffer))));"
672: echo "}"
673:
674: # permute over the radices:
675: #
676: for radix in 2 10; do
677:
678: # XXX FIXME - for now, skip quad precisions. this is just
679: # laziness over generating the constants:
680: #
681: if test "${precision}" = quad; then continue; fi
682:
683: cat <<EOF
684:
685: /* this converts an in-range IEEE 754 ${precision} precision value into its
686: radix ${radix} mantissa and exponent. the mantissa is either zero, or
687: in the range [1,${radix}): */
688: void
689: tme_ieee754_${precision}_radix${radix}_mantissa_exponent(struct tme_ieee754_ctl *ieee754_ctl, const struct tme_float *src, struct tme_float *_mantissa, struct tme_float *_exponent)
690: {
691: tme_int32_t exponent;
692: EOF
693: if test ${radix} != 2; then
694: cat <<EOF
695: #if ((TME_FLOAT_FORMATS_BUILTIN & TME_FLOAT_FORMAT_IEEE754_${capprecision}) == 0)
696: ${integral} value_ieee754_buffer;
697: struct tme_float value_buffer;
698: struct tme_float zero_buffer;
699: struct tme_float one_buffer;
700: struct tme_float constant_buffer;
701: struct tme_float radix_buffer;
702: ${precision_sf} * const value = (${precision_sf} *) &value_buffer.tme_float_value_ieee754_${precision};
703: const ${precision_sf} * const zero = (${precision_sf} *) &zero_buffer.tme_float_value_ieee754_${precision};
704: const ${precision_sf} * const one = (${precision_sf} *) &one_buffer.tme_float_value_ieee754_${precision};
705: const ${precision_sf} * const constant = (${precision_sf} *) &constant_buffer.tme_float_value_ieee754_${precision};
706: const ${precision_sf} * const radix = (${precision_sf} *) &radix_buffer.tme_float_value_ieee754_${precision};
707: tme_uint32_t exponent_bit;
708: int negate;
709: #endif /* ((TME_FLOAT_FORMATS_BUILTIN & TME_FLOAT_FORMAT_IEEE754_${capprecision}) == 0) */
710: EOF
711: fi
712: cat <<EOF
713:
714: /* check for a NaN operand: */
715: if (__tme_predict_false(tme_ieee754_${precision}_check_nan_monadic(ieee754_ctl, src, _mantissa))) {
716: if (_exponent != NULL) {
717: *_exponent = *_mantissa;
718: }
719: return;
720: }
721:
722: /* if this is an infinity: */
723: if (tme_ieee754_${precision}_is_inf(src)) {
724:
725: /* return a NaN: */
726: _mantissa->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision};
727: _mantissa->tme_float_value_ieee754_${precision} = ieee754_ctl->tme_ieee754_ctl_default_nan_${precision};
728: if (_exponent != NULL) {
729: *_exponent = *_mantissa;
730: }
731: return;
732: }
733: EOF
734: if test ${radix} = 2; then
735: echo ""
736: echo " /* extract the unbiased exponent: */"
737: echo " exponent = TME_FIELD_MASK_EXTRACTU(src->tme_float_value_ieee754_${precision}${sexp}, ${mask_exp});"
738: echo " exponent -= ${exp_bias};"
739: echo ""
740: echo " /* the mantissa is the source with a biased zero for the exponent: */"
741: echo " *_mantissa = *src;"
742: echo " TME_FIELD_MASK_DEPOSITU(_mantissa->tme_float_value_ieee754_${precision}${sexp}, ${mask_exp}, ${exp_bias});"
743: else
744: cat <<EOF
745:
746: /* if a builtin type matches the IEEE 754 ${precision} format exactly,
747: use the corresponding mantissa-exponent function: */
748: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_FLOAT)
749: tme_ieee754_${precision}_value_builtin_set
750: (_mantissa,
751: TME_FLOAT_FORMAT_FLOAT,
752: tme_float_radix${radix}_mantissa_exponent_float(tme_ieee754_${precision}_value_builtin_get(src), &exponent));
753: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_DOUBLE)
754: tme_ieee754_${precision}_value_builtin_set
755: (_mantissa,
756: TME_FLOAT_FORMAT_DOUBLE,
757: tme_float_radix${radix}_mantissa_exponent_double(tme_ieee754_${precision}_value_builtin_get(src), &exponent));
758: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_LONG_DOUBLE))
759: tme_ieee754_${precision}_value_builtin_set
760: (_mantissa,
761: TME_FLOAT_FORMAT_LONG_DOUBLE,
762: tme_float_radix${radix}_mantissa_exponent_long_double(tme_ieee754_${precision}_value_builtin_get(src), &exponent));
763: #else
764:
765: /* get this value and some constants: */
766: tme_ieee754_${precision}_value_set(&value_buffer, *tme_ieee754_${precision}_value_get(src, &value_ieee754_buffer));
767: tme_ieee754_${precision}_value_set_constant(&zero_buffer, &tme_ieee754_${precision}_constant_zero);
768: tme_ieee754_${precision}_value_set_constant(&one_buffer, &tme_ieee754_${precision}_constant_one);
769: tme_ieee754_${precision}_value_set_constant(&radix_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[0]);
770:
771: /* take the magnitude of the value, but remember if it was negative: */
772: negate = ${precision_sf}_lt(*value, *zero);
773: if (negate) {
774: *value = ${precision_sf}_sub(*zero, *value);
775: }
776:
777: /* start with an exponent of zero: */
778: exponent = 0;
779:
780: /* if the value is nonzero: */
781: if (!${precision_sf}_eq(*value, *zero)) {
782:
783: /* while the value is less than one: */
784: exponent_bit = TME_ARRAY_ELS(tme_ieee754_${precision}_constant_${radix}e_minus_2ex) - 1;
785: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e_minus_2ex[exponent_bit]);
786: for (; ${precision_sf}_lt(*value, *one); ) {
787:
788: /* if value is less than or equal to ${radix}^-(2^exponent_bit),
789: divide value by ${radix}^-(2^exponent_bit), and subtract 2^exponent_bit
790: from exponent: */
791: if (${precision_sf}_le(*value, *constant)
792: || exponent_bit == 0) {
793: *value = ${precision_sf}_div(*value, *constant);
794: exponent -= (1 << exponent_bit);
795: }
796:
797: /* otherwise, move to the next exponent bit: */
798: else {
799: exponent_bit--;
800: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e_minus_2ex[exponent_bit]);
801: }
802: }
803:
804: /* while the value is greater than ${radix}: */
805: exponent_bit = TME_ARRAY_ELS(tme_ieee754_${precision}_constant_${radix}e2ex) - 1;
806: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[exponent_bit]);
807: for (; !(${precision_sf}_le(*value, *radix)) ; ) {
808:
809: /* if value is greater than or equal to ${radix}^(2^exponent_bit),
810: divide value by ${radix}^(2^exponent_bit), and add 2^exponent_bit
811: to exponent: */
812: if (!(${precision_sf}_lt(*value, *constant))
813: || exponent_bit == 0) {
814: *value = ${precision_sf}_div(*value, *constant);
815: exponent += (1 << exponent_bit);
816: }
817:
818: /* otherwise, move to the next exponent bit: */
819: else {
820: exponent_bit--;
821: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[exponent_bit]);
822: }
823: }
824:
825: /* if the value was originally negative, negate the mantissa: */
826: if (negate) {
827: *value = ${precision_sf}_sub(*zero, *value);
828: }
829:
830: /* return the mantissa: */
831: _tme_ieee754_${precision}_value_set(_mantissa, ${precision_sf}, *value);
832: }
833: #endif
834: EOF
835: fi
836: cat <<EOF
837:
838: /* return the exponent: */
839: if (_exponent != NULL) {
840: _tme_ieee754_${precision}_value_set(_exponent, ${precision_sf}, int32_to_${precision_sf}(exponent));
841: }
842: }
843:
844: /* this scales an IEEE 754 ${precision} precision value by adding n to its
845: radix ${radix} exponent: */
846: void
847: tme_ieee754_${precision}_radix${radix}_scale(struct tme_ieee754_ctl *ieee754_ctl, const struct tme_float *src0, const struct tme_float *src1, struct tme_float *dst)
848: {
849: ${integral} src_buffer;
850: tme_int8_t rounding_mode;
851: tme_int32_t _n;
852: #if ((TME_FLOAT_FORMATS_BUILTIN & TME_FLOAT_FORMAT_IEEE754_${capprecision}) == 0)
853: tme_int32_t exponent;
854: tme_uint32_t exponent_bit, n;
855: ${precision_sf} * const value = (${precision_sf} *) &dst->tme_float_value_ieee754_${precision};
856: struct tme_float constant_buffer;
857: const ${precision_sf} * const constant = (${precision_sf} *) &constant_buffer.tme_float_value_ieee754_${precision};
858: #endif /* ((TME_FLOAT_FORMATS_BUILTIN & TME_FLOAT_FORMAT_IEEE754_${capprecision}) == 0) */
859:
860: /* check for a NaN operand: */
861: if (__tme_predict_false(tme_ieee754_${precision}_check_nan_dyadic(ieee754_ctl, src0, src1, dst))) {
862: return;
863: }
864:
865: /* if the exponent is an infinity: */
866: if (tme_ieee754_${precision}_is_inf(src1)) {
867:
868: /* return a NaN: */
869: dst->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision};
870: dst->tme_float_value_ieee754_${precision} = ieee754_ctl->tme_ieee754_ctl_default_nan_${precision};
871: return;
872: }
873:
874: /* if the operand is a zero or an infinity: */
875: if (tme_ieee754_${precision}_is_zero(src1)
876: || tme_ieee754_${precision}_is_inf(src1)) {
877:
878: /* return the operand unchanged: */
879: *dst = *src0;
880: return;
881: }
882:
883: /* truncate the exponent to an integer, using the round-to-zero mode: */
884: rounding_mode = ieee754_ctl->tme_ieee754_ctl_rounding_mode;
885: ieee754_ctl->tme_ieee754_ctl_rounding_mode = TME_FLOAT_ROUND_TO_ZERO;
886: _n = ${precision_sf}_to_int32(*((const ${precision_sf} *) tme_ieee754_${precision}_value_get(src1, &src_buffer)));
887: ieee754_ctl->tme_ieee754_ctl_rounding_mode = rounding_mode;
888:
889: /* if a builtin type matches the IEEE 754 ${precision} format exactly,
890: use the corresponding mantissa-exponent function: */
891: #if (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_FLOAT)
892: tme_ieee754_${precision}_value_builtin_set
893: (dst,
894: TME_FLOAT_FORMAT_FLOAT,
895: tme_float_radix${radix}_scale_float(tme_ieee754_${precision}_value_builtin_get(src0), _n));
896: #elif (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_DOUBLE)
897: tme_ieee754_${precision}_value_builtin_set
898: (dst,
899: TME_FLOAT_FORMAT_DOUBLE,
900: tme_float_radix${radix}_scale_double(tme_ieee754_${precision}_value_builtin_get(src0), _n));
901: #elif (defined(_TME_HAVE_LONG_DOUBLE) && (TME_FLOAT_FORMAT_IEEE754_${capprecision} == TME_FLOAT_FORMAT_LONG_DOUBLE))
902: tme_ieee754_${precision}_value_builtin_set
903: (dst,
904: TME_FLOAT_FORMAT_LONG_DOUBLE,
905: tme_float_radix${radix}_scale_long_double(tme_ieee754_${precision}_value_builtin_get(src0), _n));
906: #else
907:
908: /* start this value: */
909: tme_ieee754_${precision}_value_set(dst, *tme_ieee754_${precision}_value_get(src0, &src_buffer));
910:
911: /* start with the most significant exponent bit: */
912: exponent_bit = TME_ARRAY_ELS(tme_ieee754_${precision}_constant_${radix}e2ex) - 1;
913: exponent = (1 << exponent_bit);
914: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[exponent_bit]);
915:
916: /* if n is negative: */
917: if (_n < 0) {
918:
919: for (n = 0 - _n; n > 0;) {
920: if (n >= exponent || exponent == 1) {
921: *value = ${precision_sf}_div(*value, *constant);
922: n -= exponent;
923: }
924: else {
925: exponent >>= 1;
926: exponent_bit--;
927: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[exponent_bit]);
928: }
929: }
930: }
931:
932: /* otherwise, n is positive: */
933: else {
934: for (n = _n; n > 0;) {
935: if (n >= exponent || exponent == 1) {
936: *value = ${precision_sf}_mul(*value, *constant);
937: n -= exponent;
938: }
939: else {
940: exponent >>= 1;
941: exponent_bit--;
942: tme_ieee754_${precision}_value_set_constant(&constant_buffer, &tme_ieee754_${precision}_constant_${radix}e2ex[exponent_bit]);
943: }
944: }
945: }
946: #endif
947: }
948: EOF
949: done
950:
951: fi
952: done
953:
954: # done:
955: #
956: exit 0;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.