From 82f3f70253bb4050a6b9b924ecfccf5a6113d8de Mon Sep 17 00:00:00 2001 From: Klaus Treichel Date: Sat, 15 May 2010 14:46:37 +0200 Subject: [PATCH] Add intrinsics for direct conversion from float32 and float64 to the various integer types and float32 to float64 and vice versa. --- ChangeLog | 23 +++ include/jit/jit-intrinsic.h | 46 +++++ jit/jit-intrinsic.c | 378 +++++++++++++++++++++++++++++++++++- jit/jit-symbol.c | 26 +++ jit/jit-value.c | 92 ++++----- 5 files changed, 514 insertions(+), 51 deletions(-) diff --git a/ChangeLog b/ChangeLog index 7d5c0a4..b8b5e9b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,26 @@ +2010-05-15 Klaus Treichel + + * jit/jit-instrinsic.c ((jit_float32_to_int, jit_float32_to_uint, + jit_float32_to_long, jit_float32_to_ulong, jit_float32_to_int_ovf, + jit_float32_to_uint_ovf, jit_float32_to_long_ovf, + jit_float32_to_ulong_ovf, jit_float64_to_int, jit_float64_to_uint, + jit_float64_to_long, jit_float64_to_ulong, jit_float64_to_int_ovf, + jit_float64_to_uint_ovf, jit_float64_to_long_ovf, + jit_float64_to_ulong_ovf, jit_int_to_float32, jit_int_to_float64, + jit_uint_to_float32, jit_uint_to_float64, jit_long_to_float32, + jit_long_to_float64, jit_ulong_to_float32, jit_ulong_to_float64, + jit_float32_to_float64, jit_float64_to_float32): Add intrinsics for + direct conversion from float32 and float64 to the various integer + types and float32 to float64 and vice versa. + + * include/jit/jit-intrinsic.h: Add the prototypes for the new + intrinsics. + + * jit/jit-symbol.c: Add the new intrinsics to the symbol table. + + * jit/jit-value.c (jit_constant_convert): Use the new intrinsics in + constant conversions. + 2010-05-08 Klaus Treichel * jit/jit-block.c (_jit_block_clean_cfg): Don't merge an empty block diff --git a/include/jit/jit-intrinsic.h b/include/jit/jit-intrinsic.h index 07f30e8..2b28ab2 100644 --- a/include/jit/jit-intrinsic.h +++ b/include/jit/jit-intrinsic.h @@ -367,6 +367,42 @@ jit_int jit_ulong_to_uint_ovf(jit_uint *result, jit_ulong value) JIT_NOTHROW; jit_int jit_ulong_to_long_ovf(jit_long *result, jit_ulong value) JIT_NOTHROW; jit_int jit_ulong_to_ulong_ovf(jit_ulong *result, jit_ulong value) JIT_NOTHROW; +/* + * Convert a 32-bit floating-point value into various integer types. + */ +jit_int jit_float32_to_int(jit_float32 value) JIT_NOTHROW; +jit_uint jit_float32_to_uint(jit_float32 value) JIT_NOTHROW; +jit_long jit_float32_to_long(jit_float32 value) JIT_NOTHROW; +jit_ulong jit_float32_to_ulong(jit_float32 value) JIT_NOTHROW; + +/* + * Convert a 32-bit floating-point value into various integer types, + * with overflow detection. + */ +jit_int jit_float32_to_int_ovf(jit_int *result, jit_float32 value) JIT_NOTHROW; +jit_int jit_float32_to_uint_ovf(jit_uint *result, jit_float32 value) JIT_NOTHROW; +jit_int jit_float32_to_long_ovf(jit_long *result, jit_float32 value) JIT_NOTHROW; +jit_int jit_float32_to_ulong_ovf + (jit_ulong *result, jit_float32 value) JIT_NOTHROW; + +/* + * Convert a 64-bit floating-point value into various integer types. + */ +jit_int jit_float64_to_int(jit_float64 value) JIT_NOTHROW; +jit_uint jit_float64_to_uint(jit_float64 value) JIT_NOTHROW; +jit_long jit_float64_to_long(jit_float64 value) JIT_NOTHROW; +jit_ulong jit_float64_to_ulong(jit_float64 value) JIT_NOTHROW; + +/* + * Convert a 64-bit floating-point value into various integer types, + * with overflow detection. + */ +jit_int jit_float64_to_int_ovf(jit_int *result, jit_float64 value) JIT_NOTHROW; +jit_int jit_float64_to_uint_ovf(jit_uint *result, jit_float64 value) JIT_NOTHROW; +jit_int jit_float64_to_long_ovf(jit_long *result, jit_float64 value) JIT_NOTHROW; +jit_int jit_float64_to_ulong_ovf + (jit_ulong *result, jit_float64 value) JIT_NOTHROW; + /* * Convert a native floating-point value into various integer types. */ @@ -388,15 +424,25 @@ jit_int jit_nfloat_to_ulong_ovf /* * Convert integer types into floating-point values. */ +jit_float32 jit_int_to_float32(jit_int value) JIT_NOTHROW; +jit_float64 jit_int_to_float64(jit_int value) JIT_NOTHROW; jit_nfloat jit_int_to_nfloat(jit_int value) JIT_NOTHROW; +jit_float32 jit_uint_to_float32(jit_uint value) JIT_NOTHROW; +jit_float64 jit_uint_to_float64(jit_uint value) JIT_NOTHROW; jit_nfloat jit_uint_to_nfloat(jit_uint value) JIT_NOTHROW; +jit_float32 jit_long_to_float32(jit_long value) JIT_NOTHROW; +jit_float64 jit_long_to_float64(jit_long value) JIT_NOTHROW; jit_nfloat jit_long_to_nfloat(jit_long value) JIT_NOTHROW; +jit_float32 jit_ulong_to_float32(jit_ulong value) JIT_NOTHROW; +jit_float64 jit_ulong_to_float64(jit_ulong value) JIT_NOTHROW; jit_nfloat jit_ulong_to_nfloat(jit_ulong value) JIT_NOTHROW; /* * Convert between floating-point types. */ +jit_float64 jit_float32_to_float64(jit_float32 value) JIT_NOTHROW; jit_nfloat jit_float32_to_nfloat(jit_float32 value) JIT_NOTHROW; +jit_float32 jit_float64_to_float32(jit_float64 value) JIT_NOTHROW; jit_nfloat jit_float64_to_nfloat(jit_float64 value) JIT_NOTHROW; jit_float32 jit_nfloat_to_float32(jit_nfloat value) JIT_NOTHROW; jit_float64 jit_nfloat_to_float64(jit_nfloat value) JIT_NOTHROW; diff --git a/jit/jit-intrinsic.c b/jit/jit-intrinsic.c index 06d63c1..6133a2c 100644 --- a/jit/jit-intrinsic.c +++ b/jit/jit-intrinsic.c @@ -3288,6 +3288,294 @@ jit_int jit_ulong_to_ulong_ovf(jit_ulong *result, jit_ulong value) return 1; } +/*@ + * @deftypefun jit_int jit_float32_to_int (jit_float32 @var{value}) + * @deftypefunx jit_uint jit_float32_to_uint (jit_float32 @var{value}) + * @deftypefunx jit_long jit_float32_to_long (jit_float32 @var{value}) + * @deftypefunx jit_ulong jit_float32_to_ulong (jit_float32 @var{value}) + * Convert a 32-bit floating-point value into an integer. + * @end deftypefun +@*/ +jit_int jit_float32_to_int(jit_float32 value) +{ + return (jit_int)value; +} + +jit_uint jit_float32_to_uint(jit_float32 value) +{ + return (jit_uint)value; +} + +jit_long jit_float32_to_long(jit_float32 value) +{ + return (jit_long)value; +} + +jit_ulong jit_float32_to_ulong(jit_float32 value) +{ + /* Some platforms cannot perform the conversion directly, + so we need to do it in stages */ + if(jit_float32_is_finite(value)) + { + if(value >= (jit_float32)0.0) + { + if(value < (jit_float32)9223372036854775808.0) + { + return (jit_ulong)(jit_long)value; + } + else if(value < (jit_float32)18446744073709551616.0) + { + jit_long temp = (jit_long)(value - 9223372036854775808.0); + return (jit_ulong)(temp - jit_min_long); + } + else + { + return jit_max_ulong; + } + } + else + { + return 0; + } + } + else if(jit_float32_is_nan(value)) + { + return 0; + } + else if(value < (jit_float32)0.0) + { + return 0; + } + else + { + return jit_max_ulong; + } +} + +/*@ + * @deftypefun jit_int jit_float32_to_int_ovf (jit_int *@var{result}, jit_float32 @var{value}) + * @deftypefunx jit_uint jit_float32_to_uint_ovf (jit_uint *@var{result}, jit_float32 @var{value}) + * @deftypefunx jit_long jit_float32_to_long_ovf (jit_long *@var{result}, jit_float32 @var{value}) + * @deftypefunx jit_ulong jit_float32_to_ulong_ovf (jit_ulong *@var{result}, jit_float32 @var{value}) + * Convert a 32-bit floating-point value into an integer, + * with overflow detection. Returns @code{JIT_RESULT_OK} if the conversion + * was successful or @code{JIT_RESULT_OVERFLOW} if an overflow occurred. + * @end deftypefun +@*/ +jit_int jit_float32_to_int_ovf(jit_int *result, jit_float32 value) +{ + if(jit_float32_is_finite(value)) + { + if(value > (jit_float32)(-2147483649.0) && + value < (jit_float32)2147483648.0) + { + *result = jit_float32_to_int(value); + return 1; + } + } + return 0; +} + +jit_int jit_float32_to_uint_ovf(jit_uint *result, jit_float32 value) +{ + if(jit_float32_is_finite(value)) + { + if(value >= (jit_float32)0.0 && + value < (jit_float32)4294967296.0) + { + *result = jit_float32_to_uint(value); + return 1; + } + } + return 0; +} + +jit_int jit_float32_to_long_ovf(jit_long *result, jit_float32 value) +{ + if(jit_float32_is_finite(value)) + { + if(value >= (jit_float32)-9223372036854775808.0 && + value < (jit_float32)9223372036854775808.0) + { + *result = jit_float32_to_long(value); + return 1; + } + else if(value < (jit_float32)0.0) + { + /* Account for the range -9223372036854775809.0 to + -9223372036854775808.0, which may get rounded + off if we aren't careful */ + value += (jit_float32)9223372036854775808.0; + if(value > (jit_float32)(-1.0)) + { + *result = jit_min_long; + return 1; + } + } + } + return 0; +} + +jit_int jit_float32_to_ulong_ovf(jit_ulong *result, jit_float32 value) +{ + if(jit_float32_is_finite(value)) + { + if(value >= (jit_float32)0.0) + { + if(value < (jit_float32)18446744073709551616.0) + { + *result = jit_float32_to_ulong(value); + return 1; + } + } + } + return 0; +} + +/*@ + * @deftypefun jit_int jit_float64_to_int (jit_float64 @var{value}) + * @deftypefunx jit_uint jit_float64_to_uint (jit_float64 @var{value}) + * @deftypefunx jit_long jit_float64_to_long (jit_float64 @var{value}) + * @deftypefunx jit_ulong jit_float64_to_ulong (jit_float64 @var{value}) + * Convert a 64-bit floating-point value into an integer. + * @end deftypefun +@*/ +jit_int jit_float64_to_int(jit_float64 value) +{ + return (jit_int)value; +} + +jit_uint jit_float64_to_uint(jit_float64 value) +{ + return (jit_uint)value; +} + +jit_long jit_float64_to_long(jit_float64 value) +{ + return (jit_long)value; +} + +jit_ulong jit_float64_to_ulong(jit_float64 value) +{ + /* Some platforms cannot perform the conversion directly, + so we need to do it in stages */ + if(jit_float64_is_finite(value)) + { + if(value >= (jit_float64)0.0) + { + if(value < (jit_float64)9223372036854775808.0) + { + return (jit_ulong)(jit_long)value; + } + else if(value < (jit_float64)18446744073709551616.0) + { + jit_long temp = (jit_long)(value - 9223372036854775808.0); + return (jit_ulong)(temp - jit_min_long); + } + else + { + return jit_max_ulong; + } + } + else + { + return 0; + } + } + else if(jit_float64_is_nan(value)) + { + return 0; + } + else if(value < (jit_float64)0.0) + { + return 0; + } + else + { + return jit_max_ulong; + } +} + +/*@ + * @deftypefun jit_int jit_float64_to_int_ovf (jit_int *@var{result}, jit_float64 @var{value}) + * @deftypefunx jit_uint jit_float64_to_uint_ovf (jit_uint *@var{result}, jit_float64 @var{value}) + * @deftypefunx jit_long jit_float64_to_long_ovf (jit_long *@var{result}, jit_float64 @var{value}) + * @deftypefunx jit_ulong jit_float64_to_ulong_ovf (jit_ulong *@var{result}, jit_float64 @var{value}) + * Convert a 64-bit floating-point value into an integer, + * with overflow detection. Returns @code{JIT_RESULT_OK} if the conversion + * was successful or @code{JIT_RESULT_OVERFLOW} if an overflow occurred. + * @end deftypefun +@*/ +jit_int jit_float64_to_int_ovf(jit_int *result, jit_float64 value) +{ + if(jit_float64_is_finite(value)) + { + if(value > (jit_float64)(-2147483649.0) && + value < (jit_float64)2147483648.0) + { + *result = jit_float64_to_int(value); + return 1; + } + } + return 0; +} + +jit_int jit_float64_to_uint_ovf(jit_uint *result, jit_float64 value) +{ + if(jit_float64_is_finite(value)) + { + if(value >= (jit_float64)0.0 && + value < (jit_float64)4294967296.0) + { + *result = jit_float64_to_uint(value); + return 1; + } + } + return 0; +} + +jit_int jit_float64_to_long_ovf(jit_long *result, jit_float64 value) +{ + if(jit_float64_is_finite(value)) + { + if(value >= (jit_float64)-9223372036854775808.0 && + value < (jit_float64)9223372036854775808.0) + { + *result = jit_float64_to_long(value); + return 1; + } + else if(value < (jit_float64)0.0) + { + /* Account for the range -9223372036854775809.0 to + -9223372036854775808.0, which may get rounded + off if we aren't careful */ + value += (jit_float64)9223372036854775808.0; + if(value > (jit_float64)(-1.0)) + { + *result = jit_min_long; + return 1; + } + } + } + return 0; +} + +jit_int jit_float64_to_ulong_ovf(jit_ulong *result, jit_float64 value) +{ + if(jit_float64_is_finite(value)) + { + if(value >= (jit_float64)0.0) + { + if(value < (jit_float64)18446744073709551616.0) + { + *result = jit_float64_to_ulong(value); + return 1; + } + } + } + return 0; +} + /*@ * @deftypefun jit_int jit_nfloat_to_int (jit_nfloat @var{value}) * @deftypefunx jit_uint jit_nfloat_to_uint (jit_nfloat @var{value}) @@ -3432,6 +3720,82 @@ jit_int jit_nfloat_to_ulong_ovf(jit_ulong *result, jit_nfloat value) return 0; } +/*@ + * @deftypefun jit_float32 jit_int_to_float32 (jit_int @var{value}) + * @deftypefunx jit_float32 jit_uint_to_float32 (jit_uint @var{value}) + * @deftypefunx jit_float32 jit_long_to_float32 (jit_long @var{value}) + * @deftypefunx jit_float32 jit_ulong_to_float32 (jit_ulong @var{value}) + * Convert an integer into 32-bit floating-point value. + * @end deftypefun +@*/ +jit_float32 jit_int_to_float32(jit_int value) +{ + return (jit_float32)value; +} + +jit_float32 jit_uint_to_float32(jit_uint value) +{ + return (jit_float32)value; +} + +jit_float32 jit_long_to_float32(jit_long value) +{ + return (jit_float32)value; +} + +jit_float32 jit_ulong_to_float32(jit_ulong value) +{ + /* Some platforms cannot perform the conversion directly, + so we need to do it in stages */ + if(value < (((jit_ulong)1) << 63)) + { + return (jit_float32)(jit_long)value; + } + else + { + return (jit_float32)((jit_long)value) + + (jit_float32)18446744073709551616.0; + } +} + +/*@ + * @deftypefun jit_float64 jit_int_to_float64 (jit_int @var{value}) + * @deftypefunx jit_float64 jit_uint_to_float64 (jit_uint @var{value}) + * @deftypefunx jit_float64 jit_long_to_float64 (jit_long @var{value}) + * @deftypefunx jit_float64 jit_ulong_to_float64 (jit_ulong @var{value}) + * Convert an integer into 64-bit floating-point value. + * @end deftypefun +@*/ +jit_float64 jit_int_to_float64(jit_int value) +{ + return (jit_float64)value; +} + +jit_float64 jit_uint_to_float64(jit_uint value) +{ + return (jit_float64)value; +} + +jit_float64 jit_long_to_float64(jit_long value) +{ + return (jit_float64)value; +} + +jit_float64 jit_ulong_to_float64(jit_ulong value) +{ + /* Some platforms cannot perform the conversion directly, + so we need to do it in stages */ + if(value < (((jit_ulong)1) << 63)) + { + return (jit_float64)(jit_long)value; + } + else + { + return (jit_float64)((jit_long)value) + + (jit_float64)18446744073709551616.0; + } +} + /*@ * @deftypefun jit_nfloat jit_int_to_nfloat (jit_int @var{value}) * @deftypefunx jit_nfloat jit_uint_to_nfloat (jit_uint @var{value}) @@ -3471,18 +3835,30 @@ jit_nfloat jit_ulong_to_nfloat(jit_ulong value) } /*@ - * @deftypefun jit_nfloat jit_float32_to_nfloat (jit_float32 @var{value}) + * @deftypefun jit_float64 jit_float32_to_float64 (jit_float32 @var{value}) + * @deftypefunx jit_nfloat jit_float32_to_nfloat (jit_float32 @var{value}) + * @deftypefunx jit_float32 jit_float64_to_float32 (jit_float64 @var{value}) * @deftypefunx jit_nfloat jit_float64_to_nfloat (jit_float64 @var{value}) * @deftypefunx jit_float32 jit_nfloat_to_float32 (jit_nfloat @var{value}) * @deftypefunx jit_float64 jit_nfloat_to_float64 (jit_nfloat @var{value}) * Convert between floating-point types. * @end deftypefun @*/ +jit_float64 jit_float32_to_float64(jit_float32 value) +{ + return (jit_float64)value; +} + jit_nfloat jit_float32_to_nfloat(jit_float32 value) { return (jit_nfloat)value; } +jit_float32 jit_float64_to_float32(jit_float64 value) +{ + return (jit_float32)value; +} + jit_nfloat jit_float64_to_nfloat(jit_float64 value) { return (jit_nfloat)value; diff --git a/jit/jit-symbol.c b/jit/jit-symbol.c index ee5ea83..9b74d1c 100644 --- a/jit/jit-symbol.c +++ b/jit/jit-symbol.c @@ -76,7 +76,16 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_float32_sub", (void *)jit_float32_sub}, {"jit_float32_tan", (void *)jit_float32_tan}, {"jit_float32_tanh", (void *)jit_float32_tanh}, + {"jit_float32_to_float64", (void *)jit_float32_to_float64}, + {"jit_float32_to_int", (void *)jit_float32_to_int}, + {"jit_float32_to_int_ovf", (void *)jit_float32_to_int_ovf}, + {"jit_float32_to_long", (void *)jit_float32_to_long}, + {"jit_float32_to_long_ovf", (void *)jit_float32_to_long_ovf}, {"jit_float32_to_nfloat", (void *)jit_float32_to_nfloat}, + {"jit_float32_to_uint", (void *)jit_float32_to_uint}, + {"jit_float32_to_uint_ovf", (void *)jit_float32_to_uint_ovf}, + {"jit_float32_to_ulong", (void *)jit_float32_to_ulong}, + {"jit_float32_to_ulong_ovf", (void *)jit_float32_to_ulong_ovf}, {"jit_float64_abs", (void *)jit_float64_abs}, {"jit_float64_acos", (void *)jit_float64_acos}, {"jit_float64_add", (void *)jit_float64_add}, @@ -118,7 +127,16 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_float64_sub", (void *)jit_float64_sub}, {"jit_float64_tan", (void *)jit_float64_tan}, {"jit_float64_tanh", (void *)jit_float64_tanh}, + {"jit_float64_to_float32", (void *)jit_float64_to_float32}, + {"jit_float64_to_int", (void *)jit_float64_to_int}, + {"jit_float64_to_int_ovf", (void *)jit_float64_to_int_ovf}, + {"jit_float64_to_long", (void *)jit_float64_to_long}, + {"jit_float64_to_long_ovf", (void *)jit_float64_to_long_ovf}, {"jit_float64_to_nfloat", (void *)jit_float64_to_nfloat}, + {"jit_float64_to_uint", (void *)jit_float64_to_uint}, + {"jit_float64_to_uint_ovf", (void *)jit_float64_to_uint_ovf}, + {"jit_float64_to_ulong", (void *)jit_float64_to_ulong}, + {"jit_float64_to_ulong_ovf", (void *)jit_float64_to_ulong_ovf}, {"jit_int_abs", (void *)jit_int_abs}, {"jit_int_add", (void *)jit_int_add}, {"jit_int_add_ovf", (void *)jit_int_add_ovf}, @@ -144,6 +162,8 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_int_sign", (void *)jit_int_sign}, {"jit_int_sub", (void *)jit_int_sub}, {"jit_int_sub_ovf", (void *)jit_int_sub_ovf}, + {"jit_int_to_float32", (void *)jit_int_to_float32}, + {"jit_int_to_float64", (void *)jit_int_to_float64}, {"jit_int_to_int", (void *)jit_int_to_int}, {"jit_int_to_int_ovf", (void *)jit_int_to_int_ovf}, {"jit_int_to_long", (void *)jit_int_to_long}, @@ -187,6 +207,8 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_long_sign", (void *)jit_long_sign}, {"jit_long_sub", (void *)jit_long_sub}, {"jit_long_sub_ovf", (void *)jit_long_sub_ovf}, + {"jit_long_to_float32", (void *)jit_long_to_float32}, + {"jit_long_to_float64", (void *)jit_long_to_float64}, {"jit_long_to_int", (void *)jit_long_to_int}, {"jit_long_to_int_ovf", (void *)jit_long_to_int_ovf}, {"jit_long_to_long", (void *)jit_long_to_long}, @@ -271,6 +293,8 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_uint_shr", (void *)jit_uint_shr}, {"jit_uint_sub", (void *)jit_uint_sub}, {"jit_uint_sub_ovf", (void *)jit_uint_sub_ovf}, + {"jit_uint_to_float32", (void *)jit_uint_to_float32}, + {"jit_uint_to_float64", (void *)jit_uint_to_float64}, {"jit_uint_to_int", (void *)jit_uint_to_int}, {"jit_uint_to_int_ovf", (void *)jit_uint_to_int_ovf}, {"jit_uint_to_long", (void *)jit_uint_to_long}, @@ -304,6 +328,8 @@ jit_internalsym const _jit_internal_symbols[] = { {"jit_ulong_shr", (void *)jit_ulong_shr}, {"jit_ulong_sub", (void *)jit_ulong_sub}, {"jit_ulong_sub_ovf", (void *)jit_ulong_sub_ovf}, + {"jit_ulong_to_float32", (void *)jit_ulong_to_float32}, + {"jit_ulong_to_float64", (void *)jit_ulong_to_float64}, {"jit_ulong_to_int", (void *)jit_ulong_to_int}, {"jit_ulong_to_int_ovf", (void *)jit_ulong_to_int_ovf}, {"jit_ulong_to_long", (void *)jit_ulong_to_long}, diff --git a/jit/jit-value.c b/jit/jit-value.c index cfed89e..bedbe35 100644 --- a/jit/jit-value.c +++ b/jit/jit-value.c @@ -1170,7 +1170,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float32_to_int_ovf (&(result->un.int_value), value->un.float32_value)) { @@ -1187,7 +1187,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_sbyte - (jit_nfloat_to_int(value->un.float32_value)); + (jit_float32_to_int(value->un.float32_value)); } } break; @@ -1196,7 +1196,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float64_to_int_ovf (&(result->un.int_value), value->un.float64_value)) { @@ -1213,7 +1213,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_sbyte - (jit_nfloat_to_int(value->un.float64_value)); + (jit_float64_to_int(value->un.float64_value)); } } break; @@ -1354,7 +1354,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float32_to_int_ovf (&(result->un.int_value), value->un.float32_value)) { @@ -1371,7 +1371,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_ubyte - (jit_nfloat_to_int(value->un.float32_value)); + (jit_float32_to_int(value->un.float32_value)); } } break; @@ -1380,7 +1380,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float64_to_int_ovf (&(result->un.int_value), value->un.float64_value)) { @@ -1397,7 +1397,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_ubyte - (jit_nfloat_to_int(value->un.float64_value)); + (jit_float64_to_int(value->un.float64_value)); } } break; @@ -1538,7 +1538,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float32_to_int_ovf (&(result->un.int_value), value->un.float32_value)) { @@ -1555,7 +1555,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_short - (jit_nfloat_to_int(value->un.float32_value)); + (jit_float32_to_int(value->un.float32_value)); } } break; @@ -1564,7 +1564,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float64_to_int_ovf (&(result->un.int_value), value->un.float64_value)) { @@ -1581,7 +1581,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_short - (jit_nfloat_to_int(value->un.float64_value)); + (jit_float64_to_int(value->un.float64_value)); } } break; @@ -1722,7 +1722,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float32_to_int_ovf (&(result->un.int_value), value->un.float32_value)) { @@ -1739,7 +1739,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_ushort - (jit_nfloat_to_int(value->un.float32_value)); + (jit_float32_to_int(value->un.float32_value)); } } break; @@ -1748,7 +1748,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float64_to_int_ovf (&(result->un.int_value), value->un.float64_value)) { @@ -1765,7 +1765,7 @@ int jit_constant_convert { result->un.int_value = jit_int_to_ushort - (jit_nfloat_to_int(value->un.float64_value)); + (jit_float64_to_int(value->un.float64_value)); } } break; @@ -1873,7 +1873,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float32_to_int_ovf (&(result->un.int_value), value->un.float32_value)) { @@ -1883,7 +1883,7 @@ int jit_constant_convert else { result->un.int_value = - jit_nfloat_to_int(value->un.float32_value); + jit_float32_to_int(value->un.float32_value); } } break; @@ -1892,7 +1892,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_int_ovf + if(!jit_float64_to_int_ovf (&(result->un.int_value), value->un.float64_value)) { @@ -1902,7 +1902,7 @@ int jit_constant_convert else { result->un.int_value = - jit_nfloat_to_int(value->un.float64_value); + jit_float64_to_int(value->un.float64_value); } } break; @@ -2003,7 +2003,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_uint_ovf + if(!jit_float32_to_uint_ovf (&(result->un.uint_value), value->un.float32_value)) { @@ -2013,7 +2013,7 @@ int jit_constant_convert else { result->un.uint_value = - jit_nfloat_to_uint(value->un.float32_value); + jit_float32_to_uint(value->un.float32_value); } } break; @@ -2022,7 +2022,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_uint_ovf + if(!jit_float64_to_uint_ovf (&(result->un.uint_value), value->un.float64_value)) { @@ -2032,7 +2032,7 @@ int jit_constant_convert else { result->un.uint_value = - jit_nfloat_to_uint(value->un.float64_value); + jit_float64_to_uint(value->un.float64_value); } } break; @@ -2109,7 +2109,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_long_ovf + if(!jit_float32_to_long_ovf (&(result->un.long_value), value->un.float32_value)) { @@ -2119,7 +2119,7 @@ int jit_constant_convert else { result->un.long_value = - jit_nfloat_to_long(value->un.float32_value); + jit_float32_to_long(value->un.float32_value); } } break; @@ -2128,7 +2128,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_long_ovf + if(!jit_float64_to_long_ovf (&(result->un.long_value), value->un.float64_value)) { @@ -2138,7 +2138,7 @@ int jit_constant_convert else { result->un.long_value = - jit_nfloat_to_long(value->un.float64_value); + jit_float64_to_long(value->un.float64_value); } } break; @@ -2227,7 +2227,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_ulong_ovf + if(!jit_float32_to_ulong_ovf (&(result->un.ulong_value), value->un.float32_value)) { @@ -2237,7 +2237,7 @@ int jit_constant_convert else { result->un.ulong_value = - jit_nfloat_to_ulong(value->un.float32_value); + jit_float32_to_ulong(value->un.float32_value); } } break; @@ -2246,7 +2246,7 @@ int jit_constant_convert { if(overflow_check) { - if(!jit_nfloat_to_ulong_ovf + if(!jit_float64_to_ulong_ovf (&(result->un.ulong_value), value->un.float64_value)) { @@ -2256,7 +2256,7 @@ int jit_constant_convert else { result->un.ulong_value = - jit_nfloat_to_ulong(value->un.float64_value); + jit_float64_to_ulong(value->un.float64_value); } } break; @@ -2293,32 +2293,28 @@ int jit_constant_convert case JIT_TYPE_INT: { result->un.float32_value = - jit_nfloat_to_float32 - (jit_int_to_nfloat(value->un.int_value)); + jit_int_to_float32(value->un.int_value); } break; case JIT_TYPE_UINT: { result->un.float32_value = - jit_nfloat_to_float32 - (jit_uint_to_nfloat(value->un.uint_value)); + jit_uint_to_float32(value->un.uint_value); } break; case JIT_TYPE_LONG: { result->un.float32_value = - jit_nfloat_to_float32 - (jit_long_to_nfloat(value->un.long_value)); + jit_long_to_float32(value->un.long_value); } break; case JIT_TYPE_ULONG: { result->un.float32_value = - jit_nfloat_to_float32 - (jit_ulong_to_nfloat(value->un.ulong_value)); + jit_ulong_to_float32(value->un.ulong_value); } break; @@ -2331,7 +2327,7 @@ int jit_constant_convert case JIT_TYPE_FLOAT64: { result->un.float32_value = - jit_nfloat_to_float32(value->un.float64_value); + jit_float64_to_float32(value->un.float64_value); } break; @@ -2355,39 +2351,35 @@ int jit_constant_convert case JIT_TYPE_INT: { result->un.float64_value = - jit_nfloat_to_float64 - (jit_int_to_nfloat(value->un.int_value)); + jit_int_to_float64(value->un.int_value); } break; case JIT_TYPE_UINT: { result->un.float64_value = - jit_nfloat_to_float64 - (jit_uint_to_nfloat(value->un.uint_value)); + jit_uint_to_float64(value->un.uint_value); } break; case JIT_TYPE_LONG: { result->un.float64_value = - jit_nfloat_to_float64 - (jit_long_to_nfloat(value->un.long_value)); + jit_long_to_float64(value->un.long_value); } break; case JIT_TYPE_ULONG: { result->un.float64_value = - jit_nfloat_to_float64 - (jit_ulong_to_nfloat(value->un.ulong_value)); + jit_ulong_to_float64(value->un.ulong_value); } break; case JIT_TYPE_FLOAT32: { result->un.float64_value = - jit_nfloat_to_float64(value->un.float32_value); + jit_float32_to_float64(value->un.float32_value); } break; -- 2.47.3