Add opcodes for direct conversions from and to 32-bit and 64-bit

floatingpoint values.

diff --git a/ChangeLog b/ChangeLog
index c0f24ac79f5d6dfb4ddbadef04d85c43873fe8c1..e53376a9507a9dcd6c92abfae1fa84060cf9b120 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2010-08-07  Klaus Treichel  <ktreichel@web.de>
+
+       * config/jit-opcodes.ops: Add opcodes for direct conversions from
+       and to 32-bit and 64-bit floatingpoint values.
+
+       * jit/jit-interp.c (_jit_run_function): Add support for the new
+       opcodes.
+
+       * jit/jit-insn.c: Add the new opcodes to the convert_intrinsics
+       table.
+       (jit_insn_convert): Use the new opcodes for conversions from and to
+       32-bit and 64-bit floatingpoint values.
+
 2010-08-06  Klaus Treichel  <ktreichel@web.de>
 
        * configure.ac: Add checks for the rint, round and trunc c library

diff --git a/config/jit-opcodes.ops b/config/jit-opcodes.ops
index 4cec16f4ba588ea8de70ec5522560f85664d8383..25adf7f3f5b598d56ddbf4823be6af3e99e1be39 100644 (file)
--- a/config/jit-opcodes.ops
+++ b/config/jit-opcodes.ops
@@ -93,6 +93,32 @@ opcodes(JIT_OP_, "jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES]")
        op_def("check_signed_low_word") { op_values(int, long) }
        op_def("check_long") { op_values(long, long) }
        op_def("check_ulong") { op_values(long, long) }
+       op_def("float32_to_int") { op_values(int, float32) }
+       op_def("float32_to_uint") { op_values(int, float32) }
+       op_def("float32_to_long") { op_values(long, float32) }
+       op_def("float32_to_ulong") { op_values(long, float32) }
+       op_def("check_float32_to_int") { op_values(int, float32) }
+       op_def("check_float32_to_uint") { op_values(int, float32) }
+       op_def("check_float32_to_long") { op_values(long, float32) }
+       op_def("check_float32_to_ulong") { op_values(long, float32) }
+       op_def("int_to_float32") { op_values(float32, int) }
+       op_def("uint_to_float32") { op_values(float32, int) }
+       op_def("long_to_float32") { op_values(float32, long) }
+       op_def("ulong_to_float32") { op_values(float32, long) }
+       op_def("float32_to_float64") { op_values(float64, float32) }
+       op_def("float64_to_int") { op_values(int, float64) }
+       op_def("float64_to_uint") { op_values(int, float64) }
+       op_def("float64_to_long") { op_values(long, float64) }
+       op_def("float64_to_ulong") { op_values(long, float64) }
+       op_def("check_float64_to_int") { op_values(int, float64) }
+       op_def("check_float64_to_uint") { op_values(int, float64) }
+       op_def("check_float64_to_long") { op_values(long, float64) }
+       op_def("check_float64_to_ulong") { op_values(long, float64) }
+       op_def("int_to_float64") { op_values(float64, int) }
+       op_def("uint_to_float64") { op_values(float64, int) }
+       op_def("long_to_float64") { op_values(float64, long) }
+       op_def("ulong_to_float64") { op_values(float64, long) }
+       op_def("float64_to_float32") { op_values(float32, float64) }
        op_def("nfloat_to_int") { op_values(int, nfloat) }
        op_def("nfloat_to_uint") { op_values(int, nfloat) }
        op_def("nfloat_to_long") { op_values(long, nfloat) }

diff --git a/jit/jit-insn.c b/jit/jit-insn.c
index a593f4bfb599c121b9599e8c14f80d804822856c..65c6606a4086ea8736068f191af6762a5c301dc9 100644 (file)
--- a/jit/jit-insn.c
+++ b/jit/jit-insn.c
@@ -4272,6 +4272,32 @@ static jit_convert_intrinsic_t const convert_intrinsics[] = {
        CVT_INTRINSIC_CHECK(jit_long_to_int_ovf, long, int),
        CVT_INTRINSIC_CHECK(jit_ulong_to_long_ovf, ulong, long),
        CVT_INTRINSIC_CHECK(jit_long_to_ulong_ovf, long, ulong),
+       CVT_INTRINSIC(jit_float32_to_int, float32, int),
+       CVT_INTRINSIC(jit_float32_to_uint, float32, uint),
+       CVT_INTRINSIC(jit_float32_to_long, float32, long),
+       CVT_INTRINSIC(jit_float32_to_ulong, float32, ulong),
+       CVT_INTRINSIC_CHECK(jit_float32_to_int_ovf, float32, int),
+       CVT_INTRINSIC_CHECK(jit_float32_to_uint_ovf, float32, uint),
+       CVT_INTRINSIC_CHECK(jit_float32_to_long_ovf, float32, long),
+       CVT_INTRINSIC_CHECK(jit_float32_to_ulong_ovf, float32, ulong),
+       CVT_INTRINSIC(jit_int_to_float32, int, float32),
+       CVT_INTRINSIC(jit_uint_to_float32, uint, float32),
+       CVT_INTRINSIC(jit_long_to_float32, long, float32),
+       CVT_INTRINSIC(jit_ulong_to_float32, ulong, float32),
+       CVT_INTRINSIC(jit_float32_to_float64, float32, float64),
+       CVT_INTRINSIC(jit_float64_to_int, float64, int),
+       CVT_INTRINSIC(jit_float64_to_uint, float64, uint),
+       CVT_INTRINSIC(jit_float64_to_long, float64, long),
+       CVT_INTRINSIC(jit_float64_to_ulong, float64, ulong),
+       CVT_INTRINSIC_CHECK(jit_float64_to_int_ovf, float64, int),
+       CVT_INTRINSIC_CHECK(jit_float64_to_uint_ovf, float64, uint),
+       CVT_INTRINSIC_CHECK(jit_float64_to_long_ovf, float64, long),
+       CVT_INTRINSIC_CHECK(jit_float64_to_ulong_ovf, float64, ulong),
+       CVT_INTRINSIC(jit_int_to_float64, int, float64),
+       CVT_INTRINSIC(jit_uint_to_float64, uint, float64),
+       CVT_INTRINSIC(jit_long_to_float64, long, float64),
+       CVT_INTRINSIC(jit_ulong_to_float64, ulong, float64),
+       CVT_INTRINSIC(jit_float64_to_float32, float64, float32),
        CVT_INTRINSIC(jit_nfloat_to_int, nfloat, int),
        CVT_INTRINSIC(jit_nfloat_to_uint, nfloat, uint),
        CVT_INTRINSIC(jit_nfloat_to_long, nfloat, long),
@@ -4402,19 +4428,19 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT(JIT_OP_CHECK_INT, int),
                                        CVT(JIT_OP_CHECK_SBYTE, sbyte)},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_SBYTE, sbyte)},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_SBYTE, sbyte)},
+                               {CVT(JIT_OP_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_SBYTE, sbyte),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_SBYTE, sbyte),
+                                       CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_SBYTE, sbyte)},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_SBYTE, sbyte)},
+                               {CVT(JIT_OP_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_SBYTE, sbyte),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_SBYTE, sbyte),
+                                       CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_INT, int),
                                        CVT(JIT_OP_TRUNC_SBYTE, sbyte),
@@ -4464,19 +4490,19 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT(JIT_OP_CHECK_UBYTE, ubyte),
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_UBYTE, ubyte)},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_UBYTE, ubyte)},
+                               {CVT(JIT_OP_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_UBYTE, ubyte),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_UBYTE, ubyte),
+                                       CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_UBYTE, ubyte)},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_UBYTE, ubyte)},
+                               {CVT(JIT_OP_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_UBYTE, ubyte),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_UBYTE, ubyte),
+                                       CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_INT, int),
                                        CVT(JIT_OP_TRUNC_UBYTE, ubyte),
@@ -4526,19 +4552,19 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT(JIT_OP_CHECK_INT, int),
                                        CVT(JIT_OP_CHECK_SHORT, short)},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_SHORT, short)},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_SHORT, short)},
+                               {CVT(JIT_OP_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_SHORT, short),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_SHORT, short),
+                                       CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_SHORT, short)},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_SHORT, short)},
+                               {CVT(JIT_OP_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_SHORT, short),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_SHORT, short),
+                                       CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_INT, int),
                                        CVT(JIT_OP_TRUNC_SHORT, short),
@@ -4588,19 +4614,19 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT(JIT_OP_CHECK_USHORT, ushort),
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_USHORT, ushort)},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_USHORT, ushort)},
+                               {CVT(JIT_OP_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_USHORT, ushort),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_USHORT, ushort),
+                                       CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_TRUNC_USHORT, ushort)},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
-                                       CVT(JIT_OP_CHECK_USHORT, ushort)},
+                               {CVT(JIT_OP_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_TRUNC_USHORT, ushort),
+                                       CVT_NONE},
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_INT, int),
+                                       CVT(JIT_OP_CHECK_USHORT, ushort),
+                                       CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_INT, int),
                                        CVT(JIT_OP_TRUNC_USHORT, ushort),
@@ -4662,18 +4688,18 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT(JIT_OP_CHECK_INT, int),
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
+                               {CVT(JIT_OP_FLOAT32_TO_INT, int),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_INT, int),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_INT, int),
+                               {CVT(JIT_OP_FLOAT64_TO_INT, int),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_INT, int),
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_INT, int),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_INT, int),
@@ -4728,18 +4754,18 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT_NONE,
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_UINT, uint),
+                               {CVT(JIT_OP_FLOAT32_TO_UINT, uint),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_UINT, uint),
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_UINT, uint),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_UINT, uint),
+                               {CVT(JIT_OP_FLOAT64_TO_UINT, uint),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_UINT, uint),
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_UINT, uint),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_UINT, uint),
@@ -4790,18 +4816,18 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT_NONE,
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_LONG, long),
+                               {CVT(JIT_OP_FLOAT32_TO_LONG, long),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_LONG, long),
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_LONG, long),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_LONG, long),
+                               {CVT(JIT_OP_FLOAT64_TO_LONG, long),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_LONG, long),
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_LONG, long),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_LONG, long),
@@ -4852,18 +4878,18 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT_NONE,
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_ULONG, ulong),
+                               {CVT(JIT_OP_FLOAT32_TO_ULONG, ulong),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_ULONG, ulong),
+                               {CVT(JIT_OP_CHECK_FLOAT32_TO_ULONG, ulong),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_ULONG, ulong),
+                               {CVT(JIT_OP_FLOAT64_TO_ULONG, ulong),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_CHECK_NFLOAT_TO_ULONG, ulong),
+                               {CVT(JIT_OP_CHECK_FLOAT64_TO_ULONG, ulong),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_ULONG, ulong),
@@ -4884,34 +4910,34 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                /* from signed byte */
                                /* from signed short */
                                /* from signed int */
-                               {CVT(JIT_OP_INT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_INT_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_INT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_INT_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from unsigned byte */
                                /* from unsigned short */
                                /* from unsigned int */
-                               {CVT(JIT_OP_UINT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_UINT_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_UINT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_UINT_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from signed long */
-                               {CVT(JIT_OP_LONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_LONG_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_LONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_LONG_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from unsigned long */
-                               {CVT(JIT_OP_ULONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_ULONG_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_ULONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_ULONG_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 32-bit float */
                                {CVT(JIT_OP_COPY_FLOAT32, float32),
@@ -4921,11 +4947,11 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                        CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_FLOAT64_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT64_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
+                               {CVT(JIT_OP_FLOAT64_TO_FLOAT32, float32),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from native float */
                                {CVT(JIT_OP_NFLOAT_TO_FLOAT32, float32),
@@ -4946,41 +4972,41 @@ jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
                                /* from signed byte */
                                /* from signed short */
                                /* from signed int */
-                               {CVT(JIT_OP_INT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_INT_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_INT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_INT_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from unsigned byte */
                                /* from unsigned short */
                                /* from unsigned int */
-                               {CVT(JIT_OP_UINT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_UINT_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_UINT_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_UINT_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from signed long */
-                               {CVT(JIT_OP_LONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_LONG_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_LONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_LONG_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from unsigned long */
-                               {CVT(JIT_OP_ULONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_ULONG_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_ULONG_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_ULONG_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 32-bit float */
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_FLOAT32_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
-                               {CVT(JIT_OP_FLOAT32_TO_NFLOAT, nfloat),
-                                       CVT(JIT_OP_NFLOAT_TO_FLOAT64, float64),
+                               {CVT(JIT_OP_FLOAT32_TO_FLOAT64, float64),
+                                       CVT_NONE,
                                        CVT_NONE},
                                /* from 64-bit float */
                                {CVT(JIT_OP_COPY_FLOAT64, float64),

diff --git a/jit/jit-interp.c b/jit/jit-interp.c
index bf484e42f8447aabb0865495a9ffbb1d656535b9..f91072e217c4546bb0d67671e0ea3dbc9aa22f29 100644 (file)
--- a/jit/jit-interp.c
+++ b/jit/jit-interp.c
@@ -522,6 +522,214 @@ restart_tail:
                }
                VMBREAK;
 
+               VMCASE(JIT_OP_FLOAT32_TO_INT):
+               {
+                       /* Convert 32-bit float into 32-bit signed integer */
+                       VM_R0_INT = jit_float32_to_int(VM_R1_FLOAT32);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT32_TO_UINT):
+               {
+                       /* Convert 32-bit float into 32-bit unsigned integer */
+                       VM_R0_UINT = jit_float32_to_uint(VM_R1_FLOAT32);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT32_TO_LONG):
+               {
+                       /* Convert 32-bit float into 64-bit signed integer */
+                       VM_R0_LONG = jit_float32_to_long(VM_R1_FLOAT32);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT32_TO_ULONG):
+               {
+                       /* Convert 32-bit float into 64-bit unsigned integer */
+                       VM_R0_ULONG = jit_float32_to_ulong(VM_R1_FLOAT32);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT32_TO_INT):
+               {
+                       /* Convert 32-bit float into 32-bit signed integer, and check */
+                       VM_BUILTIN(jit_float32_to_int_ovf(&VM_R0_INT, VM_R1_FLOAT32));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT32_TO_UINT):
+               {
+                       /* Convert 32-bit float into 32-bit unsigned integer, and check */
+                       VM_BUILTIN(jit_float32_to_uint_ovf(&VM_R0_UINT, VM_R1_FLOAT32));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT32_TO_LONG):
+               {
+                       /* Convert 32-bit float into 64-bit signed integer, and check */
+                       VM_BUILTIN(jit_float32_to_long_ovf(&VM_R0_LONG, VM_R1_FLOAT32));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT32_TO_ULONG):
+               {
+                       /* Convert 32-bit float into 64-bit unsigned integer, and check */
+                       VM_BUILTIN(jit_float32_to_ulong_ovf(&VM_R0_ULONG, VM_R1_FLOAT32));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_INT_TO_FLOAT32):
+               {
+                       /* Convert 32-bit signed integer into 32-bit float */
+                       VM_R0_FLOAT32 = jit_int_to_float32(VM_R1_INT);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_UINT_TO_FLOAT32):
+               {
+                       /* Convert 32-bit unsigned integer into 32-bit float */
+                       VM_R0_FLOAT32 = jit_uint_to_float32(VM_R1_UINT);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_LONG_TO_FLOAT32):
+               {
+                       /* Convert 64-bit signed integer into 32-bit float */
+                       VM_R0_FLOAT32 = jit_long_to_float32(VM_R1_LONG);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_ULONG_TO_FLOAT32):
+               {
+                       /* Convert 64-bit unsigned integer into 32-bit float */
+                       VM_R0_FLOAT32 = jit_ulong_to_float32(VM_R1_ULONG);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT32_TO_FLOAT64):
+               {
+                       /* Convert 32-bit float into 64-bit float */
+                       VM_R0_FLOAT64 = jit_float32_to_float64(VM_R1_FLOAT32);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT64_TO_INT):
+               {
+                       /* Convert 64-bit float into 32-bit signed integer */
+                       VM_R0_INT = jit_float64_to_int(VM_R1_FLOAT64);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT64_TO_UINT):
+               {
+                       /* Convert 64-bit float into 32-bit unsigned integer */
+                       VM_R0_UINT = jit_float64_to_uint(VM_R1_FLOAT64);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT64_TO_LONG):
+               {
+                       /* Convert 64-bit float into 64-bit signed integer */
+                       VM_R0_LONG = jit_float64_to_long(VM_R1_FLOAT64);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT64_TO_ULONG):
+               {
+                       /* Convert 64-bit float into 64-bit unsigned integer */
+                       VM_R0_ULONG = jit_float64_to_ulong(VM_R1_FLOAT64);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT64_TO_INT):
+               {
+                       /* Convert 64-bit float into 32-bit signed integer, and check */
+                       VM_BUILTIN(jit_float64_to_int_ovf(&VM_R0_INT, VM_R1_FLOAT64));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT64_TO_UINT):
+               {
+                       /* Convert 64-bit float into 32-bit unsigned integer, and check */
+                       VM_BUILTIN(jit_float64_to_uint_ovf(&VM_R0_UINT, VM_R1_FLOAT64));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT64_TO_LONG):
+               {
+                       /* Convert 64-bit float into 64-bit signed integer, and check */
+                       VM_BUILTIN(jit_float64_to_long_ovf(&VM_R0_LONG, VM_R1_FLOAT64));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_CHECK_FLOAT64_TO_ULONG):
+               {
+                       /* Convert 64-bit float into 64-bit unsigned integer, and check */
+                       VM_BUILTIN(jit_float64_to_ulong_ovf(&VM_R0_ULONG, VM_R1_FLOAT64));
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_INT_TO_FLOAT64):
+               {
+                       /* Convert 32-bit signed integer into 64-bit float */
+                       VM_R0_FLOAT64 = jit_int_to_float64(VM_R1_INT);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_UINT_TO_FLOAT64):
+               {
+                       /* Convert 32-bit unsigned integer into 64-bit float */
+                       VM_R0_FLOAT64 = jit_uint_to_float64(VM_R1_UINT);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_LONG_TO_FLOAT64):
+               {
+                       /* Convert 64-bit signed integer into 64-bit float */
+                       VM_R0_FLOAT64 = jit_long_to_float64(VM_R1_LONG);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_ULONG_TO_FLOAT64):
+               {
+                       /* Convert 64-bit unsigned integer into 64-bit float */
+                       VM_R0_FLOAT64 = jit_ulong_to_float64(VM_R1_ULONG);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
+               VMCASE(JIT_OP_FLOAT64_TO_FLOAT32):
+               {
+                       /* Convert 64-bit float into 32-bit float */
+                       VM_R0_FLOAT32 = jit_float64_to_float32(VM_R1_FLOAT64);
+                       VM_MODIFY_PC(1);
+               }
+               VMBREAK;
+
                VMCASE(JIT_OP_NFLOAT_TO_INT):
                {
                        /* Convert native float into 32-bit signed integer */