Add support for some of the new opcodes for x86_64.

diff --git a/ChangeLog b/ChangeLog
index 06e206fa756678498a778dbcae124c02f6b326a3..6ebce746b6105e759b8f4b64e1a04104f14b6c0b 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2010-08-09  Klaus Treichel  <ktreichel@web.de
+
+       * jit/jit-gen-x86-64.h: Add macros for the cvttss2si and cvttsd2si
+       instructions.
+
+       * jit-rules-x86-64.ins  (JIT_OP_FLOAT32_TO_INT,
+       JIT_OP_FLOAT32_TO_UINT, JIT_OP_FLOAT32_TO_LONG,
+       JIT_OP_INT_TO_FLOAT32, JIT_OP_UINT_TO_FLOAT32,
+       JIT_OP_LONG_TO_FLOAT32, JIT_OP_FLOAT64_TO_FLOAT32,
+       JIT_OP_FLOAT64_TO_INT, JIT_OP_FLOAT64_TO_UINT,
+       JIT_OP_FLOAT64_TO_LONG, JIT_OP_INT_TO_FLOAT64,
+       JIT_OP_UINT_TO_FLOAT64, JIT_OP_LONG_TO_FLOAT64,
+       JIT_OP_FLOAT32_TO_FLOAT64: Add support for these new opcodes.
+
 2010-08-08  Klaus Treichel  <ktreichel@web.de>
 
        * jit/jit-rules-x86.ins (JIT_OP_FLOAT32_TO_INT,

diff --git a/jit/jit-gen-x86-64.h b/jit/jit-gen-x86-64.h
index 2a15ee781334761f0ff2068804f9fd5d9d6fc68e..3443be829fc90c58e487c65a0546866c358be02b 100644 (file)
--- a/jit/jit-gen-x86-64.h
+++ b/jit/jit-gen-x86-64.h
@@ -4106,6 +4106,35 @@ typedef union
                x86_64_p1_xmm2_reg_memindex_size((inst), 0xf3, 0x0f, 0x2d, (dreg), (basereg), (disp), (indexreg), (shift), (size)); \
        } while(0)
 
+/*
+ * cvttss2si: Convert float32.to a signed integer using the truncate rounding mode.
+ * The size is the size of the integer value (4 or 8)
+ */
+#define x86_64_cvttss2si_reg_reg_size(inst, dreg, sxreg, size) \
+       do { \
+               x86_64_p1_xmm2_reg_reg_size((inst), 0xf3, 0x0f, 0x2c, (dreg), (sxreg), (size)); \
+       } while(0)
+
+#define x86_64_cvttss2si_reg_regp_size(inst, dreg, sregp, size) \
+       do { \
+               x86_64_p1_xmm2_reg_regp_size((inst), 0xf3, 0x0f, 0x2c, (dreg), (sregp), (size)); \
+       } while(0)
+
+#define x86_64_cvttss2si_reg_mem_size(inst, dreg, mem, size) \
+       do { \
+               x86_64_p1_xmm2_reg_mem_size((inst), 0xf3, 0x0f, 0x2c, (dreg), (mem), (size)); \
+       } while(0)
+
+#define x86_64_cvttss2si_reg_membase_size(inst, dreg, basereg, disp, size) \
+       do { \
+               x86_64_p1_xmm2_reg_membase_size((inst), 0xf3, 0x0f, 0x2c, (dreg), (basereg), (disp), (size)); \
+       } while(0)
+
+#define x86_64_cvttss2si_reg_memindex_size(inst, dreg, basereg, disp, indexreg, shift, size) \
+       do { \
+               x86_64_p1_xmm2_reg_memindex_size((inst), 0xf3, 0x0f, 0x2c, (dreg), (basereg), (disp), (indexreg), (shift), (size)); \
+       } while(0)
+
 /*
  * cvtsd2si: Convert float64 to a signed integer using the rounding mode
  * in the mxcsr register
@@ -4136,6 +4165,35 @@ typedef union
                x86_64_p1_xmm2_reg_memindex_size((inst), 0xf2, 0x0f, 0x2d, (dreg), (basereg), (disp), (indexreg), (shift), (size)); \
        } while(0)
 
+/*
+ * cvttsd2si: Convert float64 to a signed integer using the truncate rounding mode.
+ * The size is the size of the integer value (4 or 8)
+ */
+#define x86_64_cvttsd2si_reg_reg_size(inst, dreg, sxreg, size) \
+       do { \
+               x86_64_p1_xmm2_reg_reg_size((inst), 0xf2, 0x0f, 0x2c, (dreg), (sxreg), (size)); \
+       } while(0)
+
+#define x86_64_cvttsd2si_reg_regp_size(inst, dreg, sregp, size) \
+       do { \
+               x86_64_p1_xmm2_reg_regp_size((inst), 0xf2, 0x0f, 0x2c, (dreg), (sregp), (size)); \
+       } while(0)
+
+#define x86_64_cvttsd2si_reg_mem_size(inst, dreg, mem, size) \
+       do { \
+               x86_64_p1_xmm2_reg_mem_size((inst), 0xf2, 0x0f, 0x2c, (dreg), (mem), (size)); \
+       } while(0)
+
+#define x86_64_cvttsd2si_reg_membase_size(inst, dreg, basereg, disp, size) \
+       do { \
+               x86_64_p1_xmm2_reg_membase_size((inst), 0xf2, 0x0f, 0x2c, (dreg), (basereg), (disp), (size)); \
+       } while(0)
+
+#define x86_64_cvttsd2si_reg_memindex_size(inst, dreg, basereg, disp, indexreg, shift, size) \
+       do { \
+               x86_64_p1_xmm2_reg_memindex_size((inst), 0xf2, 0x0f, 0x2c, (dreg), (basereg), (disp), (indexreg), (shift), (size)); \
+       } while(0)
+
 /*
  * cvtss2sd: Convert float32 to float64
  */

diff --git a/jit/jit-rules-x86-64.ins b/jit/jit-rules-x86-64.ins
index f8a10968be6f63eded075757373e0c32ed484590..f03b9e54f7f73688922a75f92310ac3165ad359e 100644 (file)
--- a/jit/jit-rules-x86-64.ins
+++ b/jit/jit-rules-x86-64.ins
@@ -122,6 +122,114 @@ JIT_OP_LONG_TO_NFLOAT:
 #endif
        }
 
+JIT_OP_FLOAT32_TO_INT:
+       [=reg, local] -> {
+               x86_64_cvttss2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 4);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttss2si_reg_reg_size(inst, $1, $2, 4);
+       }
+
+JIT_OP_FLOAT32_TO_UINT:
+       [=reg, local] -> {
+               x86_64_cvttss2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttss2si_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_FLOAT32_TO_LONG:
+       [=reg, local] -> {
+               x86_64_cvttss2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttss2si_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_INT_TO_FLOAT32:
+       [=xreg, local] -> {
+               x86_64_cvtsi2ss_reg_membase_size(inst, $1, X86_64_RBP, $2, 4);
+       }
+       [=xreg, reg] -> {
+               x86_64_cvtsi2ss_reg_reg_size(inst, $1, $2, 4);
+       }
+
+JIT_OP_UINT_TO_FLOAT32:
+       [=xreg, reg] -> {
+               x86_64_mov_reg_reg_size(inst, $2, $2, 4);
+               x86_64_cvtsi2ss_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_LONG_TO_FLOAT32:
+       [=xreg, local] -> {
+               x86_64_cvtsi2ss_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=xreg, reg] -> {
+               x86_64_cvtsi2ss_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_FLOAT64_TO_FLOAT32:
+       [=xreg, local] -> {
+               x86_64_cvtsd2ss_reg_membase(inst, $1, X86_64_RBP, $2);
+       }
+       [=xreg, xreg] -> {
+               x86_64_cvtsd2ss_reg_reg(inst, $1, $2);
+       }
+
+JIT_OP_FLOAT64_TO_INT:
+       [=reg, local] -> {
+               x86_64_cvttsd2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 4);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttsd2si_reg_reg_size(inst, $1, $2, 4);
+       }
+
+JIT_OP_FLOAT64_TO_UINT:
+       [=reg, local] -> {
+               x86_64_cvttsd2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttsd2si_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_FLOAT64_TO_LONG:
+       [=reg, local] -> {
+               x86_64_cvttsd2si_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=reg, xreg] -> {
+               x86_64_cvttsd2si_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_INT_TO_FLOAT64:
+       [=xreg, local] -> {
+               x86_64_cvtsi2sd_reg_membase_size(inst, $1, X86_64_RBP, $2, 4);
+       }
+       [=xreg, reg] -> {
+               x86_64_cvtsi2sd_reg_reg_size(inst, $1, $2, 4);
+       }
+
+JIT_OP_UINT_TO_FLOAT64:
+       [=xreg, reg] -> {
+               x86_64_mov_reg_reg_size(inst, $2, $2, 4);
+               x86_64_cvtsi2sd_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_LONG_TO_FLOAT64:
+       [=xreg, local] -> {
+               x86_64_cvtsi2sd_reg_membase_size(inst, $1, X86_64_RBP, $2, 8);
+       }
+       [=xreg, reg] -> {
+               x86_64_cvtsi2sd_reg_reg_size(inst, $1, $2, 8);
+       }
+
+JIT_OP_FLOAT32_TO_FLOAT64:
+       [=xreg, local] -> {
+               x86_64_cvtss2sd_reg_membase(inst, $1, X86_64_RBP, $2);
+       }
+       [=xreg, xreg] -> {
+               x86_64_cvtss2sd_reg_reg(inst, $1, $2);
+       }
+
 JIT_OP_NFLOAT_TO_INT: stack
        [=reg, freg, scratch reg] -> {
                inst = x86_64_nfloat_to_int(inst, $1, $3, 4);