![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ieee754-ops-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-ops-auto.sh CVS log | Up to [The Machine Emulator] / tme / ic / ieee754 |
1.1 root 1: #! /bin/sh
2:
3: # $Id: ieee754-ops-auto.sh,v 1.2 2005/03/23 11:47:37 fredette Exp $
4:
5: # ic/ieee754/ieee754-misc-auto.sh - automatically generates C code
6: # for IEEE 754 emulation operations:
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-ops-auto.sh,v 1.2 2005/03/23 11:47:37 fredette Exp $");
53:
54: EOF
55: if $header; then
56: :
57: else
58: cat <<EOF
59: #include "softfloat-tme.h"
60: #include <math.h>
61: EOF
62: fi
63:
64: # the precision information helper script:
65: #
66: ieee754_precision_sh=`echo $0 | sed -e "s/$PROG/ieee754-precision.sh/"`
67:
68: # the different compliance levels:
69: #
70: levels="strict partial unknown"
71:
72: # permute for the different compliance levels:
73: #
74: for level in ${levels}; do
75:
76: # permute for functions or for a set:
77: #
78: for what in funcs set; do
79:
80: # if we're generating headers:
81: #
82: if $header; then
83:
84: # if we're doing the strict-level functions, start the
85: # operations struct type:
86: #
87: if test "${level}-${what}" = strict-funcs; then
88: echo "/* the IEEE 754 operations: */"
89: echo "struct tme_ieee754_ops {"
90: echo ""
91: echo " /* the version of this structure: */"
92: echo " tme_uint32_t tme_ieee754_ops_version;"
93:
94:
95: # otherwise, if we're doing a set, just declare the set
96: # and continue:
97: #
98: elif test ${what} = set; then
99: echo ""
100: echo "/* the ${level} compliance operations: */"
101: echo "extern _tme_const struct tme_ieee754_ops tme_ieee754_ops_${level};"
102: continue
103: fi
104:
105: # otherwise, if we're doing a set:
106: #
107: elif test ${what} = set; then
108:
109: # start the operations set for this level:
110: #
111: echo ""
112: echo "/* the ${level} compliance operations: */"
113: echo "_tme_const struct tme_ieee754_ops tme_ieee754_ops_${level} = {"
114: echo ""
115: echo " /* the version of this structure: */"
116: echo " TME_X_VERSION(0, 0),"
117: fi
118:
119: # permute for the different precisions:
120: #
121: for precision in single double extended80 quad; do
122:
123: # get information about this precision:
124: #
125: eval `sh ${ieee754_precision_sh} ${precision}`
126:
127: # generate the operations:
128: #
129: for name in add sub mul div \
130: rem sqrt abs neg move \
131: rint \
132: cos acos cosh \
133: sin asin sinh \
134: tan atan tanh atanh \
135: exp expm1 log10 log log1p \
136: getexp getman scale \
137: pow \
138: from_single from_double from_extended80 from_quad \
139: to_int32 to_int64 \
140: ; do
141:
142: # get the characteristics of this operation that are the
143: # same at all compliance levels:
144: #
145: monadic=true
146: case "${name}" in
147: add | sub | mul | div | rem | pow | scale)
148: monadic=false
149: ;;
150: esac
151: dst_type="struct tme_float"
152: case "${name}" in
153: to_int32) dst_type="tme_int32_t" ;;
154: esac
155:
156: # we don't need a function to convert from the same
157: # precision to this precision:
158: #
159: from_precision=
160: case "${name}" in
161: from_*)
162: from_precision=`echo ${name} | sed -e 's/^from_//'`
163: if test ${from_precision} = ${precision}; then
164: continue
165: fi
166: ;;
167: esac
168:
169: # if we're generating headers:
170: #
171: if $header; then
172:
173: # only emit this header information if we're
174: # doing the strict level functions:
175: #
176: if test "${level}-${what}" = strict-funcs; then
177: echo ""
178: echo " /* this does a ${precision}-precision "`echo ${name} | tr _ -`": */"
179: echo -n " void (*tme_ieee754_ops_${precision}_${name}) _TME_P((struct tme_ieee754_ctl *, "
180: if $monadic; then :; else
181: echo -n "_tme_const struct tme_float *, "
182: fi
183: echo "_tme_const struct tme_float *, ${dst_type} *));"
184: fi
185:
186: continue
187: fi
188:
189: # start with no function for this set:
190: #
191: func_set=' NULL,'
192:
193: # permute for the stricter compliance levels:
194: #
195: for level_stricter in ${levels}; do
196:
197: # form this function name:
198: #
199: func="_tme_ieee754_${level_stricter}_${precision}_${name}"
200:
201: # the function type is normally determined by
202: # whether or not a softfloat function, libm
203: # function, or C operator is given. it can be
204: # overridden:
205: #
206: type=
207: func_softfloat=
208: func_libm=
209: func_libm_has_f=true
210: op_builtin=
211:
212: # any preprocessor condition controlling whether or not
213: # the function can be emitted is normally determined by
214: # the function type. it can be overridden:
215: #
216: cond=
217:
218: # assume that we will use the operands as passed
219: # in. the precisions will later default to the
220: # precision of the result, if they are not
221: # overridden:
222: #
223: op0=src0
224: op0_precision=
225: if $monadic; then op1= ; else op1=src1 ; fi
226: op1_precision=
227:
228: # miscellaneous attributes:
229: #
230: src0_buffer=
231: src0_precision=
232: src1_buffer=
233: src1_precision=
234: check_nan=
235: check_inf_src0=
236: enter_softfloat=
237: enter_native=
238:
239: # characterize this operation at this compliance level:
240: #
241: case "${level_stricter}-${name}" in
242: strict-add | strict-sub | strict-mul | strict-div | strict-rem | strict-sqrt)
243: func_softfloat="${name}"
244: ;;
245: *-add) op_builtin='+' ;;
246: *-sub) op_builtin='-' ;;
247: *-mul) op_builtin='*' ;;
248: *-div) op_builtin='/' ;;
249: *-sqrt) func_libm=sqrt ;;
250: partial-abs | unknown-abs) func_libm=fabs ;;
251: strict-neg) op0=0 ; func_softfloat=sub ; op1=src0 ;;
252: partial-neg | unknown-neg) op0=0 ; op_builtin='-'; op1=src0 ;;
253: strict-move) func_softfloat=add ; op1=0 ;;
254: *-move) type="${level_stricter}-move" ; src0_buffer=false ;;
255: strict-rint) func_softfloat=round_to_int ;;
256: partial-pow | unknown-pow) func_libm="${name}" ;;
257: partial-log | unknown-log) func_libm="${name}" ;;
258: partial-exp | unknown-exp) func_libm="${name}" ;;
259: partial-log10 | unknown-log10) func_libm="${name}" ;;
260: partial-scale | unknown-scale) func_libm=scalbn ;;
261: strict-getexp | strict-getman) type="${level_stricter}-${name}" ; check_nan=true ; check_inf_src0=return-nan ;;
262: strict-from_*) func_softfloat="OP0_PRECISION_SF_to_${precision_sf}" ; op0_precision="${from_precision}" ;;
263: strict-to_int32) type="${level_stricter}-${name}" ; func_softfloat="${precision_sf}_${name}" ;;
264: esac
265:
266: # finish typing this function:
267: #
268: if test "x${type}" = x; then
269: if test "x${func_softfloat}" != x; then
270: type=softfloat
271: elif test "x${func_libm}" != x; then
272: type=libm
273: elif test "x${op_builtin}" != x; then
274: type=builtin
275: else
276: type=none
277: fi
278: fi
279:
280: # finish the preprocessor condition controlling
281: # whether or not the function can be emitted:
282: #
283: if test "x${cond}" = x; then
284: case "${precision}-${level_stricter}-${type}" in
285:
286: # a function with a none type can't be emitted:
287: #
288: *-*-none) cond=0 ;;
289:
290: # extended80 or quad precision softfloat
291: # functions are conditional on a 64-bit
292: # integral type:
293: #
294: extended80-*-softfloat | quad-*-softfloat) cond="defined(TME_HAVE_INT64_T)" ;;
295:
296: # partial compliance functions are conditional
297: # on the builtin type being an exact match for
298: # the IEEE 754 type:
299: #
300: *-partial-*) cond="(TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_IEEE754_${capprecision})" ;;
301:
302: # assume that anything else can be unconditionally emitted:
303: #
304: *) cond=1 ;;
305: esac
306: fi
307:
308: # finish the operands:
309: #
310: for _opn in 0 1; do
311: eval "opn=\$op${_opn}"
312: if test "x${opn}" = x; then
313: continue
314: fi
315: eval "opn_precision=\$op${_opn}_precision"
316: if test "x${opn_precision}" = x; then
317: opn_precision="${precision}"
318: fi
319: eval `sh ${ieee754_precision_sh} ${opn_precision} opn_`
320: case "${opn}" in
321: src[01])
322: eval "${opn}_precision=\$opn_precision"
323: if test "x${func_softfloat}" != x || test "x${func_libm}${op_builtin}" = x; then
324: eval "srcn_buffer=\$${opn}_buffer"
325: if test "x${srcn_buffer}" = x; then
326: eval "${opn}_buffer=true"
327: fi
328: opn="tme_ieee754_${opn_precision}_value_get(${opn}, &${opn}_buffer)"
329: if test "x${func_softfloat}" != x; then
330: opn="((const ${opn_precision_sf} *) ${opn})"
331: fi
332: opn="(*${opn})"
333: else
334: opn="tme_ieee754_${opn_precision}_value_builtin_get(${opn})"
335: fi
336: ;;
337: [0-9])
338: if test "x${func_softfloat}" != x; then
339: opn="int32_to_${opn_precision_sf}(${opn})"
340: fi
341: ;;
342: esac
343: eval "op${_opn}=\$opn"
344: eval "op${_opn}_precision=\$opn_precision"
345: eval "op${_opn}_precision_sf=\$opn_precision_sf"
346: eval "op${_opn}_integral=\$opn_integral"
347: done
348:
349: # finish the miscellaneous attributes:
350: #
351: if test "x${src0_buffer}" = x; then
352: src0_buffer=false
353: fi
354: if test "x${src1_buffer}" = x; then
355: src1_buffer=false
356: fi
357: if test "x${check_nan}" = x; then
358: if test "${level_stricter}" = partial; then
359: check_nan=true
360: else
361: check_nan=false
362: fi
363: fi
364: if test "x${enter_softfloat}" = x; then
365: if test "x${func_softfloat}" != x; then
366: enter_softfloat=true
367: else
368: enter_softfloat=false
369: fi
370: fi
371: if test "x${enter_native}" = x; then
372: if test "${level_stricter}" = partial; then
373: enter_native=true
374: else
375: enter_native=false
376: fi
377: fi
378:
379: # if we're making functions, and we're at the
380: # right level to emit this function, and this
381: # function can be emitted:
382: #
383: if test ${what} = funcs && test ${level_stricter} = ${level} && test "${cond}" != 0; then
384:
385: # start any conditional:
386: #
387: if test "${cond}" != 1; then
388: echo ""
389: echo "#if ${cond}"
390: fi
391:
392: # start the function:
393: #
394: echo ""
395: echo "/* this does a ${level} compliance ${precision}-precision "`echo ${name} | tr _ -`": */"
396: echo "static void"
397: echo -n "${func}(struct tme_ieee754_ctl *ieee754_ctl, const struct tme_float *src0, "
398: if $monadic; then :; else
399: echo -n "const struct tme_float *src1, "
400: fi
401: echo "${dst_type} *dst)"
402: echo "{"
403:
404: # emit locals:
405: #
406: if ${src0_buffer}; then
407: echo " ${op0_integral} src0_buffer;"
408: fi
409: if ${src1_buffer}; then
410: echo " ${op1_integral} src1_buffer;"
411: fi
412: echo " int exceptions;"
413:
414: # check the operand(s):
415: #
416: if ${check_nan}; then
417: echo ""
418: echo " /* check for a NaN operand: */"
419: if $monadic; then nanf=monadic; src1= ; else nanf=dyadic; src1=", src1"; fi
420: echo " if (__tme_predict_false(tme_ieee754_${src0_precision}_check_nan_${nanf}(ieee754_ctl, src0${src1}, dst))) {"
421: echo " return;"
422: echo " }"
423: fi
424: if test "x${check_inf_src0}" != x; then
425: echo ""
426: echo " /* if the operand is an infinity: */"
427: echo " if (tme_ieee754_${precision}_is_inf(src0)) {"
428: echo ""
429: case "${check_inf_src0}" in
430: return-nan)
431: echo " /* return a NaN: */"
432: echo " dst->tme_float_format = TME_FLOAT_FORMAT_IEEE754_${capprecision};"
433: echo " dst->tme_float_value_ieee754_${precision} = ieee754_ctl->tme_ieee754_ctl_default_nan_${precision};"
434: echo " return;"
435: ;;
436: esac
437: echo " }"
438: fi
439:
440: # enter the operation mode:
441: #
442: if ${enter_softfloat}; then
443: echo ""
444: echo " /* enter softfloat operation: */"
445: echo " tme_mutex_lock(&tme_ieee754_global_mutex);"
446: echo " tme_ieee754_global_ctl = ieee754_ctl;"
447: echo " tme_ieee754_global_exceptions = 0;"
448: echo " ieee754_ctl->tme_ieee754_ctl_lock_unlock = tme_ieee754_unlock_softfloat;"
449: fi
450: if ${enter_native}; then
451: echo ""
452: echo " /* enter native floating-point operation: */"
453: echo " tme_float_enter(ieee754_ctl->tme_ieee754_ctl_rounding_mode, tme_ieee754_exception_float, ieee754_ctl);"
454: echo " ieee754_ctl->tme_ieee754_ctl_lock_unlock = tme_float_leave;"
455: fi
456:
457: # assume that this operation raises no exceptions:
458: #
459: echo ""
460: echo " /* assume that this operation raises no exceptions: */"
461: echo " exceptions = 0;"
462:
463: # the operation:
464: #
465: echo ""
466: echo " /* the operation: */"
467: case "${type}" in
468:
469: # a move operation:
470: #
471: *-move)
472: echo " *dst = *src0;"
473: ;;
474:
475: # a getexp operation:
476: #
477: strict-getexp)
478: echo ""
479: echo " /* if the operand is a zero, return a zero: */"
480: echo " if (tme_ieee754_${precision}_is_zero(src0)) {"
481: echo " tme_ieee754_${precision}_value_builtin_set(dst, TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN, 0);"
482: echo " }"
483: echo ""
484: echo " /* otherwise, return the unbiased exponent: */"
485: echo " else {"
486: echo " tme_ieee754_${precision}_value_builtin_set(dst, TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN, TME_FIELD_MASK_EXTRACTU(${op0}${sexp}, ${mask_exp}) - ${exp_bias});"
487: echo " }"
488: ;;
489:
490: # a getman operation:
491: #
492: strict-getman)
493: echo ""
494: echo " /* if the operand is a zero, return it: */"
495: echo " if (tme_ieee754_${precision}_is_zero(src0)) {"
496: echo " *dst = *src0;"
497: echo " }"
498: echo ""
499: echo " /* otherwise, return the operand, with its exponent set to biased zero: */"
500: echo " else {"
501: echo " tme_ieee754_${precision}_value_set(dst, ${op0});"
502: echo " TME_FIELD_MASK_DEPOSITU(dst->tme_float_value_ieee754_${precision}${sexp}, ${mask_exp}, ${exp_bias});"
503: echo " }"
504: ;;
505:
506: # a strict to-integer conversion operation:
507: #
508: strict-to_int32 | strict-to_int64)
509: echo " *dst = ${precision_sf}_${name}(${op0});"
510: ;;
511:
512: # a softfloat operation:
513: #
514: softfloat)
515: echo " _tme_ieee754_${precision}_value_set(dst, ${precision_sf},"
516: func_softfloat_raw="${func_softfloat}"
517: func_softfloat=`echo ${func_softfloat} | sed -e "s/OP0_PRECISION_SF/${op0_precision_sf}/g"`
518: func_softfloat=`echo ${func_softfloat} | sed -e "s/OP1_PRECISION_SF/${op0_precision_sf}/g"`
519: if test "${func_softfloat}" = "${func_softfloat_raw}"; then
520: func_softfloat="${precision_sf}_${func_softfloat}"
521: fi
522: echo -n " ${func_softfloat}(${op0}"
523: if test "x${op1}" != x; then
524: echo ","
525: echo -n " ${op1}"
526: fi
527: echo "));"
528: ;;
529:
530: # a libm operation:
531: #
532: libm)
533: if test "x${op1}" = x; then ops="${op0}"; else ops="${op0}, ${op1}"; fi
534: # if there is a float variant of this libm function:
535: #
536: if ${func_libm_has_f}; then
537: echo "#if (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN == TME_FLOAT_FORMAT_FLOAT)"
538: echo " tme_ieee754_${precision}_value_builtin_set(dst, TME_FLOAT_FORMAT_FLOAT, ${func_libm}f(${ops}));"
539: echo "#else /* (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN != TME_FLOAT_FORMAT_FLOAT) */"
540: fi
541: echo " tme_ieee754_${precision}_value_builtin_set(dst, TME_FLOAT_FORMAT_DOUBLE, ${func_libm}(${ops}));"
542: if ${func_libm_has_f}; then
543: echo "#endif /* (TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN != TME_FLOAT_FORMAT_FLOAT) */"
544: fi
545: ;;
546:
547: # a builtin operation:
548: #
549: builtin)
550: echo " tme_ieee754_${precision}_value_builtin_set(dst, TME_FLOAT_FORMAT_IEEE754_${capprecision}_BUILTIN, ${op0} ${op_builtin} ${op1});"
551: ;;
552:
553: *)
554: echo "$PROG internal error: don't know how to generate a ${type} type operation" 1>&2
555: exit 1
556: ;;
557: esac
558:
559: # leave the operation mode:
560: #
561: if ${enter_native}; then
562: echo ""
563: echo " /* leave native floating-point operation: */"
564: echo " exceptions |= tme_float_leave();"
565: fi
566: if ${enter_softfloat}; then
567: echo ""
568: echo " /* leave softfloat operation: */"
569: echo " tme_ieee754_global_ctl = NULL;"
570: echo " exceptions |= tme_ieee754_global_exceptions;"
571: echo " tme_mutex_unlock(&tme_ieee754_global_mutex);"
572: fi
573: echo " ieee754_ctl->tme_ieee754_ctl_lock_unlock = NULL;"
574:
575: # signal any exceptions:
576: #
577: echo ""
578: echo " /* signal any exceptions: */"
579: echo " if (exceptions != 0) {"
580: echo " (*ieee754_ctl->tme_ieee754_ctl_exception)(ieee754_ctl, exceptions);"
581: echo " }"
582:
583: # end the function:
584: #
585: echo "}"
586:
587: # close any conditional:
588: #
589: if test "${cond}" != 1; then
590: echo ""
591: echo "#endif /* ${cond} */"
592: fi
593: fi
594:
595: # update the function for this set:
596: #
597: case "${cond}" in
598: 0) ;;
599: 1) func_set=" ${func}," ;;
600: *) func_set="#if (${cond})@ ${func},@#else /* !(${cond}) */@${func_set}@#endif /* !(${cond}) */" ;;
601: esac
602:
603: # stop now if we just did this level:
604: #
605: if test ${level_stricter} = ${level}; then
606: break
607: fi
608: done
609:
610: # if we're making a set:
611: #
612: if test ${what} = set; then
613: echo ""
614: echo " /* this does a ${level} compliance ${precision}-precision ${name}: */"
615: echo "${func_set}" | tr '@' '\n'
616: fi
617:
618: done
619: done
620:
621: # if we're generating headers:
622: #
623: if $header; then
624:
625: # if we're doing the strict-level functions, close the
626: # operations struct type:
627: #
628: if test "${level}-${what}" = strict-funcs; then
629: echo "};"
630: fi
631:
632: # otherwise, if we're doing a set:
633: #
634: elif test ${what} = set; then
635:
636: # close the operations set for this level:
637: #
638: echo "};"
639: fi
640:
641: done
642:
643: done
644:
645: # if we're not generating headers:
646: #
647: if $header; then :; else
648:
649: echo ""
650: echo "/* this looks up an operations structure: */"
651: echo "const struct tme_ieee754_ops *"
652: echo "tme_ieee754_ops_lookup(const char *compliance)"
653: echo "{"
654: echo ""
655: for level in ${levels}; do
656: echo " if (TME_ARG_IS(compliance, \"${level}\")) { "
657: echo " return (&tme_ieee754_ops_${level});"
658: echo " }"
659: done
660: echo " return (NULL);"
661: echo "}"
662:
663: echo ""
664: echo "/* this is a compliance options string: */"
665: echo -n "const char * const tme_ieee754_compliance_options = \"{ ";
666: sep=
667: for level in ${levels}; do
668: echo -n "${sep}${level}"
669: sep=' | '
670: done
671: echo " }\";"
672: fi
673:
674: # done:
675: #
676: exit 0;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.