You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
|
|
1
(2) |
2
(7) |
3
(1) |
4
(9) |
5
|
|
6
(7) |
7
(10) |
8
(23) |
9
(19) |
10
(21) |
11
(14) |
12
(15) |
|
13
(11) |
14
(7) |
15
(20) |
16
(21) |
17
(20) |
18
(20) |
19
(19) |
|
20
(24) |
21
(22) |
22
(19) |
23
(17) |
24
(26) |
25
(15) |
26
(16) |
|
27
(8) |
28
(10) |
29
(24) |
30
(21) |
31
(19) |
|
|
|
From: <sv...@va...> - 2013-01-01 22:20:19
|
florian 2013-01-01 22:20:12 +0000 (Tue, 01 Jan 2013)
New Revision: 13215
Log:
s390: Add testcases for DFP "shift significant" insns.
Patch by Maran Pakkirisamy (ma...@li...).
Part of fixing BZ 307113.
Modified files:
trunk/none/tests/s390x/dfp-2.c
trunk/none/tests/s390x/dfp-2.stdout.exp
Modified: trunk/none/tests/s390x/dfp-2.stdout.exp (+16 -0)
===================================================================
--- trunk/none/tests/s390x/dfp-2.stdout.exp 2012-12-28 15:54:23 +00:00 (rev 13214)
+++ trunk/none/tests/s390x/dfp-2.stdout.exp 2013-01-01 22:20:12 +00:00 (rev 13215)
@@ -10,3 +10,19 @@
LTXTR 2207000000000000000a0005 -> 2
LTXTR a207000000000000000a0005 -> 1
LTXTR 2207c0000000000000000000 -> 0
+SLDT 2224014d2e7971a1 -> 6a26c34400000000
+SLDT a224014d2e7971a1 -> a224a395bcb8c880
+SLDT 2238000000000000 -> 2238000000000000
+SLDT a238000000000000 -> a238000000000000
+SRDT 2224014d2e7971a1 -> 2224000001271778
+SRDT a224014d2e7971a1 -> a22400049c5de2c3
+SRDT 2238000000000000 -> 2238000000000000
+SRDT a238000000000000 -> a238000000000000
+SLXT 2206c0000000000014d2e7971a1 -> 2206c0000000049c5de2c34400000000
+SLXT a206c0000000000014d2e7971a1 -> a206c00000000000a395bcb8c880
+SLXT 220800000000000000000000 -> 220800000000000000000000
+SLXT a20800000000000000000000 -> a20800000000000000000000
+SRXT 2206c0000000000014d2e7971a1 -> 2206c00000000000000000a3
+SRXT a206c0000000000014d2e7971a1 -> a206c0000000000049c5de2c3
+SRXT 220800000000000000000000 -> 220800000000000000000000
+SRXT a20800000000000000000000 -> a20800000000000000000000
Modified: trunk/none/tests/s390x/dfp-2.c (+86 -0)
===================================================================
--- trunk/none/tests/s390x/dfp-2.c 2012-12-28 15:54:23 +00:00 (rev 13214)
+++ trunk/none/tests/s390x/dfp-2.c 2013-01-01 22:20:12 +00:00 (rev 13215)
@@ -54,6 +54,70 @@
printf(" -> %d\n", cc);
}
+void sldt(_Decimal64 in, unsigned long amount)
+{
+ _Decimal64 out;
+ int *shift = (int *) amount;
+
+ asm volatile (".insn rxf, 0xed0000000040, %[out], %[in], 0(%[amount])\n\t"
+ :[out]"=f"(out)
+ :[in]"f"(in),[amount]"a"(shift));
+
+ printf("SLDT ");
+ DFP_VAL_PRINT(in, _Decimal64);
+ printf(" -> ");
+ DFP_VAL_PRINT(out, _Decimal64);
+ printf("\n");
+}
+
+void slxt(_Decimal128 in, unsigned long amount)
+{
+ _Decimal128 out;
+ int *shift = (int *) amount;
+
+ asm volatile (".insn rxf, 0xed0000000048, %[out], %[in], 0(%[amount])\n\t"
+ :[out]"=f"(out)
+ :[in]"f"(in),[amount]"a"(shift));
+
+ printf("SLXT ");
+ DFP_VAL_PRINT(in, _Decimal128);
+ printf(" -> ");
+ DFP_VAL_PRINT(out, _Decimal128);
+ printf("\n");
+}
+
+void srdt(_Decimal64 in, unsigned long amount)
+{
+ _Decimal64 out;
+ int *shift = (int *) amount;
+
+ asm volatile (".insn rxf, 0xed0000000041, %[out], %[in], 0(%[amount])\n\t"
+ :[out]"=f"(out)
+ :[in]"f"(in),[amount]"a"(shift));
+
+ printf("SRDT ");
+ DFP_VAL_PRINT(in, _Decimal64);
+ printf(" -> ");
+ DFP_VAL_PRINT(out, _Decimal64);
+ printf("\n");
+}
+
+void srxt(_Decimal128 in, unsigned long amount)
+{
+ _Decimal128 out;
+ int *shift = (int *) amount;
+
+ asm volatile (".insn rxf, 0xed0000000049, %[out], %[in], 0(%[amount])\n\t"
+ :[out]"=f"(out)
+ :[in]"f"(in),[amount]"a"(shift));
+
+ printf("SRXT ");
+ DFP_VAL_PRINT(in, _Decimal128);
+ printf(" -> ");
+ DFP_VAL_PRINT(out, _Decimal128);
+ printf("\n");
+}
+
int main() {
_Decimal64 d64 = 50.0005DD;
_Decimal128 d128 = 50.0005DL;
@@ -72,5 +136,27 @@
ltxtr(-d128);
ltxtr(0.0DL);
+ d64 = 12345678.54321DD;
+ sldt(d64, 10);
+ sldt(-d64, 2);
+ sldt(0.DD, 2);
+ sldt(-0.DD, 2);
+
+ srdt(d64, 5);
+ srdt(-d64, 2);
+ srdt(0.DD, 2);
+ srdt(-0.DD, 2);
+
+ d128 = 12345678.54321DL;
+ slxt(d128, 10);
+ slxt(-d128, 2);
+ slxt(0.DL, 2);
+ slxt(-0.DL, 2);
+
+ srxt(d128, 10);
+ srxt(-d128, 2);
+ srxt(0.DL, 2);
+ srxt(-0.DL, 2);
+
return 0;
}
|
|
From: <sv...@va...> - 2013-01-01 22:19:34
|
florian 2013-01-01 22:19:24 +0000 (Tue, 01 Jan 2013)
New Revision: 2626
Log:
s390: Add support for DFP "shift significant" insns.
Based on patch by Maran Pakkirisamy (ma...@li...).
Part of fixing BZ 307113.
Modified files:
trunk/priv/guest_s390_toIR.c
trunk/priv/host_s390_defs.c
trunk/priv/host_s390_defs.h
trunk/priv/host_s390_isel.c
Modified: trunk/priv/guest_s390_toIR.c (+72 -4)
===================================================================
--- trunk/priv/guest_s390_toIR.c 2012-12-30 18:17:18 +00:00 (rev 2625)
+++ trunk/priv/guest_s390_toIR.c 2013-01-01 22:19:24 +00:00 (rev 2626)
@@ -9574,6 +9574,62 @@
}
static const HChar *
+s390_irgen_SLDT(UChar r3, IRTemp op2addr, UChar r1)
+{
+ IRTemp op = newTemp(Ity_D64);
+
+ vassert(s390_host_has_dfp);
+
+ assign(op, get_dpr_dw0(r3));
+ put_dpr_dw0(r1, binop(Iop_ShlD64, mkexpr(op), unop(Iop_64to8,
+ binop(Iop_And64, mkexpr(op2addr), mkU64(63)))));
+
+ return "sldt";
+}
+
+static const HChar *
+s390_irgen_SLXT(UChar r3, IRTemp op2addr, UChar r1)
+{
+ IRTemp op = newTemp(Ity_D128);
+
+ vassert(s390_host_has_dfp);
+
+ assign(op, get_dpr_pair(r3));
+ put_dpr_pair(r1, binop(Iop_ShlD128, mkexpr(op), unop(Iop_64to8,
+ binop(Iop_And64, mkexpr(op2addr), mkU64(63)))));
+
+ return "slxt";
+}
+
+static const HChar *
+s390_irgen_SRDT(UChar r3, IRTemp op2addr, UChar r1)
+{
+ IRTemp op = newTemp(Ity_D64);
+
+ vassert(s390_host_has_dfp);
+
+ assign(op, get_dpr_dw0(r3));
+ put_dpr_dw0(r1, binop(Iop_ShrD64, mkexpr(op), unop(Iop_64to8,
+ binop(Iop_And64, mkexpr(op2addr), mkU64(63)))));
+
+ return "srdt";
+}
+
+static const HChar *
+s390_irgen_SRXT(UChar r3, IRTemp op2addr, UChar r1)
+{
+ IRTemp op = newTemp(Ity_D128);
+
+ vassert(s390_host_has_dfp);
+
+ assign(op, get_dpr_pair(r3));
+ put_dpr_pair(r1, binop(Iop_ShrD128, mkexpr(op), unop(Iop_64to8,
+ binop(Iop_And64, mkexpr(op2addr), mkU64(63)))));
+
+ return "srxt";
+}
+
+static const HChar *
s390_irgen_TDCET(UChar r1, IRTemp op2addr)
{
IRTemp value = newTemp(Ity_D32);
@@ -15103,10 +15159,22 @@
case 0xed000000003dULL: /* MYH */ goto unimplemented;
case 0xed000000003eULL: /* MAD */ goto unimplemented;
case 0xed000000003fULL: /* MSD */ goto unimplemented;
- case 0xed0000000040ULL: /* SLDT */ goto unimplemented;
- case 0xed0000000041ULL: /* SRDT */ goto unimplemented;
- case 0xed0000000048ULL: /* SLXT */ goto unimplemented;
- case 0xed0000000049ULL: /* SRXT */ goto unimplemented;
+ case 0xed0000000040ULL: s390_format_RXF_FRRDF(s390_irgen_SLDT,
+ ovl.fmt.RXF.r3, ovl.fmt.RXF.x2,
+ ovl.fmt.RXF.b2, ovl.fmt.RXF.d2,
+ ovl.fmt.RXF.r1); goto ok;
+ case 0xed0000000041ULL: s390_format_RXF_FRRDF(s390_irgen_SRDT,
+ ovl.fmt.RXF.r3, ovl.fmt.RXF.x2,
+ ovl.fmt.RXF.b2, ovl.fmt.RXF.d2,
+ ovl.fmt.RXF.r1); goto ok;
+ case 0xed0000000048ULL: s390_format_RXF_FRRDF(s390_irgen_SLXT,
+ ovl.fmt.RXF.r3, ovl.fmt.RXF.x2,
+ ovl.fmt.RXF.b2, ovl.fmt.RXF.d2,
+ ovl.fmt.RXF.r1); goto ok;
+ case 0xed0000000049ULL: s390_format_RXF_FRRDF(s390_irgen_SRXT,
+ ovl.fmt.RXF.r3, ovl.fmt.RXF.x2,
+ ovl.fmt.RXF.b2, ovl.fmt.RXF.d2,
+ ovl.fmt.RXF.r1); goto ok;
case 0xed0000000050ULL: s390_format_RXE_FRRD(s390_irgen_TDCET, ovl.fmt.RXE.r1,
ovl.fmt.RXE.x2, ovl.fmt.RXE.b2,
ovl.fmt.RXE.d2); goto ok;
Modified: trunk/priv/host_s390_defs.h (+20 -0)
===================================================================
--- trunk/priv/host_s390_defs.h 2012-12-30 18:17:18 +00:00 (rev 2625)
+++ trunk/priv/host_s390_defs.h 2013-01-01 22:19:24 +00:00 (rev 2626)
@@ -142,6 +142,7 @@
S390_INSN_BFP_CONVERT,
S390_INSN_DFP_BINOP, /* Decimal floating point */
S390_INSN_DFP_UNOP,
+ S390_INSN_DFP_INTOP,
S390_INSN_DFP_COMPARE,
S390_INSN_DFP_CONVERT,
S390_INSN_MFENCE,
@@ -261,6 +262,12 @@
S390_DFP_EXTRACT_SIG_D128,
} s390_dfp_unop_t;
+/* The DFP operations with 2 operands one of them being integer */
+typedef enum {
+ S390_DFP_SHIFT_LEFT,
+ S390_DFP_SHIFT_RIGHT
+} s390_dfp_intop_t;
+
/* The kind of DFP compare operations */
typedef enum {
S390_DFP_COMPARE,
@@ -458,6 +465,14 @@
HReg op_lo; /* 128-bit operand low part */
} dfp_unop;
struct {
+ s390_dfp_intop_t tag;
+ HReg dst_hi; /* 128-bit result high part; 64-bit result */
+ HReg dst_lo; /* 128-bit result low part */
+ HReg op2; /* integer operand */
+ HReg op3_hi; /* 128-bit operand high part; 64-bit opnd */
+ HReg op3_lo; /* 128-bit operand low part */
+ } dfp_intop;
+ struct {
s390_dfp_conv_t tag;
s390_dfp_round_t rounding_mode;
HReg dst_hi; /* 128-bit result high part; 64-bit result */
@@ -583,6 +598,8 @@
HReg op2, HReg op3,
s390_dfp_round_t rounding_mode);
s390_insn *s390_insn_dfp_unop(UChar size, s390_dfp_unop_t, HReg dst, HReg op);
+s390_insn *s390_insn_dfp_intop(UChar size, s390_dfp_intop_t, HReg dst,
+ HReg op2, HReg op3);
s390_insn *s390_insn_dfp_compare(UChar size, s390_dfp_cmp_t, HReg dst,
HReg op1, HReg op2);
s390_insn *s390_insn_dfp_convert(UChar size, s390_dfp_conv_t tag, HReg dst,
@@ -593,6 +610,9 @@
s390_dfp_round_t rounding_mode);
s390_insn *s390_insn_dfp128_unop(UChar size, s390_dfp_unop_t, HReg dst,
HReg op_hi, HReg op_lo);
+s390_insn *s390_insn_dfp128_intop(UChar size, s390_dfp_intop_t, HReg dst_hi,
+ HReg dst_lo, HReg op2,
+ HReg op3_hi, HReg op3_lo);
s390_insn *s390_insn_dfp128_compare(UChar size, s390_dfp_cmp_t, HReg dst,
HReg op1_hi, HReg op1_lo, HReg op2_hi,
HReg op2_lo);
Modified: trunk/priv/host_s390_defs.c (+179 -0)
===================================================================
--- trunk/priv/host_s390_defs.c 2012-12-30 18:17:18 +00:00 (rev 2625)
+++ trunk/priv/host_s390_defs.c 2013-01-01 22:19:24 +00:00 (rev 2626)
@@ -731,6 +731,16 @@
}
break;
+ case S390_INSN_DFP_INTOP:
+ addHRegUse(u, HRmWrite, insn->variant.dfp_intop.dst_hi);
+ addHRegUse(u, HRmRead, insn->variant.dfp_intop.op2);
+ addHRegUse(u, HRmRead, insn->variant.dfp_intop.op3_hi);
+ if (insn->size == 16) {
+ addHRegUse(u, HRmWrite, insn->variant.dfp_intop.dst_lo);
+ addHRegUse(u, HRmRead, insn->variant.dfp_intop.op3_lo);
+ }
+ break;
+
case S390_INSN_DFP_COMPARE:
addHRegUse(u, HRmWrite, insn->variant.dfp_compare.dst);
addHRegUse(u, HRmRead, insn->variant.dfp_compare.op1_hi); /* left */
@@ -1020,6 +1030,21 @@
}
break;
+ case S390_INSN_DFP_INTOP:
+ insn->variant.dfp_intop.dst_hi =
+ lookupHRegRemap(m, insn->variant.dfp_intop.dst_hi);
+ insn->variant.dfp_intop.op2 =
+ lookupHRegRemap(m, insn->variant.dfp_intop.op2);
+ insn->variant.dfp_intop.op3_hi =
+ lookupHRegRemap(m, insn->variant.dfp_intop.op3_hi);
+ if (insn->size == 16) {
+ insn->variant.dfp_intop.dst_lo =
+ lookupHRegRemap(m, insn->variant.dfp_intop.dst_lo);
+ insn->variant.dfp_intop.op3_lo =
+ lookupHRegRemap(m, insn->variant.dfp_intop.op3_lo);
+ }
+ break;
+
case S390_INSN_DFP_COMPARE:
insn->variant.dfp_compare.dst =
lookupHRegRemap(m, insn->variant.dfp_compare.dst);
@@ -1305,6 +1330,21 @@
static UChar *
+emit_RXF(UChar *p, ULong op, UChar r3, UChar x2, UChar b2, UShort d2, UChar r1)
+{
+ ULong the_insn = op;
+
+ the_insn |= ((ULong)r3) << 36;
+ the_insn |= ((ULong)x2) << 32;
+ the_insn |= ((ULong)b2) << 28;
+ the_insn |= ((ULong)d2) << 16;
+ the_insn |= ((ULong)r1) << 12;
+
+ return emit_6bytes(p, the_insn);
+}
+
+
+static UChar *
emit_RXY(UChar *p, ULong op, UChar r1, UChar x2, UChar b2, UShort dl2, UChar dh2)
{
ULong the_insn = op;
@@ -4287,6 +4327,54 @@
static UChar *
+s390_emit_SLDT(UChar *p, UChar r3, UChar r1, UChar r2)
+{
+ vassert(s390_host_has_dfp);
+ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) {
+ s390_disasm(ENC4(MNM, FPR, FPR, UDXB), "sldt", r1, r3, 0, 0, r2);
+ }
+
+ return emit_RXF(p, 0xED0000000040, r3, 0, r2, 0, r1);
+}
+
+
+static UChar *
+s390_emit_SLXT(UChar *p, UChar r3, UChar r1, UChar r2)
+{
+ vassert(s390_host_has_dfp);
+ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) {
+ s390_disasm(ENC4(MNM, FPR, FPR, UDXB), "slxt", r1, r3, 0, 0, r2);
+ }
+
+ return emit_RXF(p, 0xED0000000048, r3, 0, r2, 0, r1);
+}
+
+
+static UChar *
+s390_emit_SRDT(UChar *p, UChar r3, UChar r1, UChar r2)
+{
+ vassert(s390_host_has_dfp);
+ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) {
+ s390_disasm(ENC4(MNM, FPR, FPR, UDXB), "srdt", r1, r3, 0, 0, r2);
+ }
+
+ return emit_RXF(p, 0xED0000000041, r3, 0, r2, 0, r1);
+}
+
+
+static UChar *
+s390_emit_SRXT(UChar *p, UChar r3, UChar r1, UChar r2)
+{
+ vassert(s390_host_has_dfp);
+ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) {
+ s390_disasm(ENC4(MNM, FPR, FPR, UDXB), "srxt", r1, r3, 0, 0, r2);
+ }
+
+ return emit_RXF(p, 0xED0000000049, r3, 0, r2, 0, r1);
+}
+
+
+static UChar *
s390_emit_LOCGR(UChar *p, UChar m3, UChar r1, UChar r2)
{
vassert(s390_host_has_lsc);
@@ -5439,6 +5527,27 @@
s390_insn *
+s390_insn_dfp_intop(UChar size, s390_dfp_intop_t tag, HReg dst, HReg op2,
+ HReg op3)
+{
+ s390_insn *insn = LibVEX_Alloc(sizeof(s390_insn));
+
+ vassert(size == 8);
+
+ insn->tag = S390_INSN_DFP_INTOP;
+ insn->size = size;
+ insn->variant.dfp_intop.tag = tag;
+ insn->variant.dfp_intop.dst_hi = dst;
+ insn->variant.dfp_intop.op2 = op2;
+ insn->variant.dfp_intop.op3_hi = op3;
+ insn->variant.dfp_intop.dst_lo = INVALID_HREG;
+ insn->variant.dfp_intop.op3_lo = INVALID_HREG;
+
+ return insn;
+}
+
+
+s390_insn *
s390_insn_dfp_compare(UChar size, s390_dfp_cmp_t tag, HReg dst,
HReg op1, HReg op2)
{
@@ -5533,6 +5642,29 @@
s390_insn *
+s390_insn_dfp128_intop(UChar size, s390_dfp_intop_t tag, HReg dst_hi,
+ HReg dst_lo, HReg op2, HReg op3_hi, HReg op3_lo)
+{
+ s390_insn *insn = LibVEX_Alloc(sizeof(s390_insn));
+
+ vassert(size == 16);
+ vassert(is_valid_fp128_regpair(dst_hi, dst_lo));
+ vassert(is_valid_fp128_regpair(op3_hi, op3_lo));
+
+ insn->tag = S390_INSN_DFP_INTOP;
+ insn->size = size;
+ insn->variant.dfp_intop.tag = tag;
+ insn->variant.dfp_intop.dst_hi = dst_hi;
+ insn->variant.dfp_intop.dst_lo = dst_lo;
+ insn->variant.dfp_intop.op2 = op2;
+ insn->variant.dfp_intop.op3_hi = op3_hi;
+ insn->variant.dfp_intop.op3_lo = op3_lo;
+
+ return insn;
+}
+
+
+s390_insn *
s390_insn_dfp128_compare(UChar size, s390_dfp_cmp_t tag, HReg dst, HReg op1_hi,
HReg op1_lo, HReg op2_hi, HReg op2_lo)
{
@@ -6207,6 +6339,17 @@
insn->variant.dfp_unop.op_hi);
break;
+ case S390_INSN_DFP_INTOP:
+ switch (insn->variant.dfp_intop.tag) {
+ case S390_DFP_SHIFT_LEFT: op = "v-dshl"; break;
+ case S390_DFP_SHIFT_RIGHT: op = "v-dshr"; break;
+ default: goto fail;
+ }
+ s390_sprintf(buf, "%M %R,%R,%R", op, insn->variant.dfp_intop.dst_hi,
+ insn->variant.dfp_intop.op2,
+ insn->variant.dfp_intop.op3_hi);
+ break;
+
case S390_INSN_DFP_COMPARE:
switch (insn->variant.dfp_compare.tag) {
case S390_DFP_COMPARE: op = "v-dcmp"; break;
@@ -8413,6 +8556,38 @@
static UChar *
+s390_insn_dfp_intop_emit(UChar *buf, const s390_insn *insn)
+{
+ UInt r1 = hregNumber(insn->variant.dfp_intop.dst_hi);
+ UInt r2 = hregNumber(insn->variant.dfp_intop.op2);
+ UInt r3 = hregNumber(insn->variant.dfp_intop.op3_hi);
+
+ switch (insn->size) {
+ case 8:
+ switch (insn->variant.dfp_intop.tag) {
+ case S390_DFP_SHIFT_LEFT: return s390_emit_SLDT(buf, r3, r1, r2);
+ case S390_DFP_SHIFT_RIGHT: return s390_emit_SRDT(buf, r3, r1, r2);
+ default: goto fail;
+ }
+ break;
+
+ case 16:
+ switch (insn->variant.dfp_intop.tag) {
+ case S390_DFP_SHIFT_LEFT: return s390_emit_SLXT(buf, r3, r1, r2);
+ case S390_DFP_SHIFT_RIGHT: return s390_emit_SRXT(buf, r3, r1, r2);
+ default: goto fail;
+ }
+ break;
+
+ default: goto fail;
+ }
+
+ fail:
+ vpanic("s390_insn_dfp_intop_emit");
+}
+
+
+static UChar *
s390_insn_dfp_compare_emit(UChar *buf, const s390_insn *insn)
{
UInt dst = hregNumber(insn->variant.dfp_compare.dst);
@@ -9112,6 +9287,10 @@
end = s390_insn_dfp_unop_emit(buf, insn);
break;
+ case S390_INSN_DFP_INTOP:
+ end = s390_insn_dfp_intop_emit(buf, insn);
+ break;
+
case S390_INSN_DFP_COMPARE:
end = s390_insn_dfp_compare_emit(buf, insn);
break;
Modified: trunk/priv/host_s390_isel.c (+62 -2)
===================================================================
--- trunk/priv/host_s390_isel.c 2012-12-30 18:17:18 +00:00 (rev 2625)
+++ trunk/priv/host_s390_isel.c 2013-01-01 22:19:24 +00:00 (rev 2626)
@@ -2443,12 +2443,50 @@
/* --------- BINARY OP --------- */
case Iex_Binop: {
+
switch (expr->Iex.Binop.op) {
case Iop_D64HLtoD128:
*dst_hi = s390_isel_dfp_expr(env, expr->Iex.Binop.arg1);
*dst_lo = s390_isel_dfp_expr(env, expr->Iex.Binop.arg2);
return;
+ case Iop_ShlD128:
+ case Iop_ShrD128: {
+ HReg op1_hi, op1_lo, op2, f9, f11, f13, f15;
+ s390_dfp_intop_t intop;
+ IRExpr *left = expr->Iex.Binop.arg1;
+ IRExpr *right = expr->Iex.Binop.arg2;
+
+ switch (expr->Iex.Binop.op) {
+ case Iop_ShlD128: intop = S390_DFP_SHIFT_LEFT; break;
+ case Iop_ShrD128: intop = S390_DFP_SHIFT_RIGHT; break;
+ default: goto irreducible;
+ }
+
+ /* We use non-virtual registers as pairs (f9, f11) and (f13, f15)) */
+ f9 = make_fpr(9); /* 128 bit dfp operand */
+ f11 = make_fpr(11);
+
+ f13 = make_fpr(13); /* 128 bit dfp destination */
+ f15 = make_fpr(15);
+
+ s390_isel_dfp128_expr(&op1_hi, &op1_lo, env, left); /* dfp operand */
+ addInstr(env, s390_insn_move(8, f9, op1_hi));
+ addInstr(env, s390_insn_move(8, f11, op1_lo));
+
+ op2 = s390_isel_int_expr(env, right); /* int operand */
+
+ addInstr(env,
+ s390_insn_dfp128_intop(16, intop, f13, f15, op2, f9, f11));
+
+ /* Move result to virtual destination register */
+ *dst_hi = newVRegF(env);
+ *dst_lo = newVRegF(env);
+ addInstr(env, s390_insn_move(8, *dst_hi, f13));
+ addInstr(env, s390_insn_move(8, *dst_lo, f15));
+ return;
+ }
+
default:
goto irreducible;
}
@@ -2587,8 +2625,6 @@
rounding_mode));
return dst;
}
- default:
- goto irreducible;
case Iop_D128toD64: {
HReg op_hi, op_lo, f13, f15;
@@ -2620,7 +2656,31 @@
return dst;
}
+ case Iop_ShlD64:
+ case Iop_ShrD64: {
+ HReg op2;
+ HReg op3;
+ s390_dfp_intop_t intop;
+ IRExpr *op1 = expr->Iex.Binop.arg1;
+ IRExpr *shift = expr->Iex.Binop.arg2;
+
+ switch (expr->Iex.Binop.op) {
+ case Iop_ShlD64: intop = S390_DFP_SHIFT_LEFT; break;
+ case Iop_ShrD64: intop = S390_DFP_SHIFT_RIGHT; break;
+ default: goto irreducible;
+ }
+
+ op2 = s390_isel_int_expr(env, shift);
+ op3 = s390_isel_dfp_expr(env, op1);
+ dst = newVRegF(env);
+
+ addInstr(env, s390_insn_dfp_intop(size, intop, dst, op2, op3));
+ return dst;
}
+
+ default:
+ goto irreducible;
+ }
}
/* --------- UNARY OP --------- */
|