[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, master, updated. 1ab04e871a0152ece58462c88d073c2c1453866d

[Klaus Treichel]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "DotGNU Portable.NET Just In Time compiler (libjit)".

The branch, master has been updated
       via  1ab04e871a0152ece58462c88d073c2c1453866d (commit)
      from  c4f149eb86dbdc0759342223505d440de6d05894 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/libjit.git/commit/?id=1ab04e871a0152ece58462c88d073c2c1453866d

commit 1ab04e871a0152ece58462c88d073c2c1453866d
Author: Klaus Treichel <address@hidden>
Date:   Mon Aug 9 14:00:38 2010 +0200

    Add support for some of the new opcodes for x86_64.

diff --git a/ChangeLog b/ChangeLog
index 06e206f..6ebce74 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2010-08-09  Klaus Treichel  <address@hidden
+
+       * 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  <address@hidden>
 
        * 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 2a15ee7..3443be8 100644
--- a/jit/jit-gen-x86-64.h
+++ b/jit/jit-gen-x86-64.h
@@ -4107,6 +4107,35 @@ typedef union
        } 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
  * The size is the size of the integer value (4 or 8)
@@ -4137,6 +4166,35 @@ typedef union
        } 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
  */
 #define x86_64_cvtss2sd_reg_reg(inst, dreg, sreg) \
diff --git a/jit/jit-rules-x86-64.ins b/jit/jit-rules-x86-64.ins
index f8a1096..f03b9e5 100644
--- 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);

-----------------------------------------------------------------------

Summary of changes:
 ChangeLog                |   14 ++++++
 jit/jit-gen-x86-64.h     |   58 ++++++++++++++++++++++++
 jit/jit-rules-x86-64.ins |  108 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 180 insertions(+), 0 deletions(-)


hooks/post-receive
-- 
DotGNU Portable.NET Just In Time compiler (libjit)