various integer types and float32 to float64 and vice versa.
+2010-05-15 Klaus Treichel <ktreichel@web.de>
+
+ * 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 <ktreichel@web.de>
* jit/jit-block.c (_jit_block_clean_cfg): Don't merge an empty block
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.
*/
/*
* 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;
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})
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})
}
/*@
- * @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;
{"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},
{"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},
{"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},
{"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},
{"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},
{"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},
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float32_to_int_ovf
(&(result->un.int_value),
value->un.float32_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float64_to_int_ovf
(&(result->un.int_value),
value->un.float64_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float32_to_int_ovf
(&(result->un.int_value),
value->un.float32_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float64_to_int_ovf
(&(result->un.int_value),
value->un.float64_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float32_to_int_ovf
(&(result->un.int_value),
value->un.float32_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float64_to_int_ovf
(&(result->un.int_value),
value->un.float64_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float32_to_int_ovf
(&(result->un.int_value),
value->un.float32_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float64_to_int_ovf
(&(result->un.int_value),
value->un.float64_value))
{
{
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;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float32_to_int_ovf
(&(result->un.int_value),
value->un.float32_value))
{
else
{
result->un.int_value =
- jit_nfloat_to_int(value->un.float32_value);
+ jit_float32_to_int(value->un.float32_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_int_ovf
+ if(!jit_float64_to_int_ovf
(&(result->un.int_value),
value->un.float64_value))
{
else
{
result->un.int_value =
- jit_nfloat_to_int(value->un.float64_value);
+ jit_float64_to_int(value->un.float64_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_uint_ovf
+ if(!jit_float32_to_uint_ovf
(&(result->un.uint_value),
value->un.float32_value))
{
else
{
result->un.uint_value =
- jit_nfloat_to_uint(value->un.float32_value);
+ jit_float32_to_uint(value->un.float32_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_uint_ovf
+ if(!jit_float64_to_uint_ovf
(&(result->un.uint_value),
value->un.float64_value))
{
else
{
result->un.uint_value =
- jit_nfloat_to_uint(value->un.float64_value);
+ jit_float64_to_uint(value->un.float64_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_long_ovf
+ if(!jit_float32_to_long_ovf
(&(result->un.long_value),
value->un.float32_value))
{
else
{
result->un.long_value =
- jit_nfloat_to_long(value->un.float32_value);
+ jit_float32_to_long(value->un.float32_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_long_ovf
+ if(!jit_float64_to_long_ovf
(&(result->un.long_value),
value->un.float64_value))
{
else
{
result->un.long_value =
- jit_nfloat_to_long(value->un.float64_value);
+ jit_float64_to_long(value->un.float64_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_ulong_ovf
+ if(!jit_float32_to_ulong_ovf
(&(result->un.ulong_value),
value->un.float32_value))
{
else
{
result->un.ulong_value =
- jit_nfloat_to_ulong(value->un.float32_value);
+ jit_float32_to_ulong(value->un.float32_value);
}
}
break;
{
if(overflow_check)
{
- if(!jit_nfloat_to_ulong_ovf
+ if(!jit_float64_to_ulong_ovf
(&(result->un.ulong_value),
value->un.float64_value))
{
else
{
result->un.ulong_value =
- jit_nfloat_to_ulong(value->un.float64_value);
+ jit_float64_to_ulong(value->un.float64_value);
}
}
break;
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;
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;
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;
projects / francis / libjit.git / commitdiff