commit d74a637206ef5532ccd2ccb2e31ee2762f184e60

Author: Andreas Arnez <arnez@linux.ibm.com>

Date:   Wed Apr 28 18:52:30 2021 +0200

    Bug 433863 - s390x: Remove memcheck test cases for cs, cds, and csg

    The fix for bug 429864 - "s390x: C++ atomic test_and_set yields

    false-positive memcheck diagnostics" changes the memcheck behavior at

    various compare-and-swap instructions.  The comparison between the old and

    expected value now always yields a defined result, even if the input

    values are (partially) undefined.  However, some existing test cases

    explicitly verify that memcheck complains about the use of uninitialised

    values here.  These test cases are no longer valid.  Remove them.

diff --git a/memcheck/tests/s390x/Makefile.am b/memcheck/tests/s390x/Makefile.am

index 67ae8c293..e4e69eb38 100644

--- a/memcheck/tests/s390x/Makefile.am

+++ b/memcheck/tests/s390x/Makefile.am

@@ -2,7 +2,7 @@ include $(top_srcdir)/Makefile.tool-tests.am

 dist_noinst_SCRIPTS = filter_stderr

-INSN_TESTS = cs csg cds cdsg cu21 cu42 ltgjhe

+INSN_TESTS = cdsg cu21 cu42 ltgjhe

 check_PROGRAMS = $(INSN_TESTS) 

@@ -14,7 +14,3 @@ EXTRA_DIST = \

 AM_CFLAGS    += @FLAG_M64@

 AM_CXXFLAGS  += @FLAG_M64@

 AM_CCASFLAGS += @FLAG_M64@

-

-cs_CFLAGS     = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@

-csg_CFLAGS    = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@

-cds_CFLAGS    = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@

diff --git a/memcheck/tests/s390x/cds.c b/memcheck/tests/s390x/cds.c

deleted file mode 100644

index ec5c533e0..000000000

--- a/memcheck/tests/s390x/cds.c

+++ /dev/null

@@ -1,82 +0,0 @@

-#include <stdint.h>

-#include <stdio.h>

-

-typedef struct {

-   uint64_t high;

-   uint64_t low;

-} quad_word;

-

-void 

-test(quad_word op1_init, uint64_t op2_init, quad_word op3_init)

-{

-   int cc; // unused

-   quad_word op1 = op1_init;

-   uint64_t  op2 = op2_init;

-   quad_word op3 = op3_init;

-

-   __asm__ volatile (

-                     "lmg     %%r0,%%r1,%1\n\t"

-                     "lmg     %%r2,%%r3,%3\n\t"

-                     "cds     %%r0,%%r2,%2\n\t"  //  cds 1st,3rd,2nd

-                     "stmg    %%r0,%%r1,%1\n"    // store r0,r1 to op1

-                     "stmg    %%r2,%%r3,%3\n"    // store r2,r3 to op3

-                     : "=d" (cc), "+QS" (op1), "+QS" (op2), "+QS" (op3)

-                     :

-                     : "r0", "r1", "r2", "r3", "cc");

-

-}

-

-// Return a quad-word that only bits low[32:63] are undefined

-quad_word

-make_undefined(void)

-{

-   quad_word val;

-

-   val.high = 0;

-   val.low |= 0xFFFFFFFF00000000ull;

-

-   return val;

-}

-

-void op1_undefined(void)

-{

-   quad_word op1, op3;

-   uint64_t op2;

-

-   // op1 undefined

-   op1 = make_undefined();

-   op2 = 42;

-   op3.high = op3.low = 0xdeadbeefdeadbabeull;

-   test(op1, op2, op3);  // complaint

-}

-

-void op2_undefined(void)

-{

-   quad_word op1, op3;

-   uint64_t op2;

-

-   op1.high = op1.low = 42;

-   // op2 undefined

-   op3.high = op3.low = 0xdeadbeefdeadbabeull;

-   test(op1, op2, op3);  // complaint

-}

-

-void op3_undefined(void)

-{

-   quad_word op1, op3;

-   uint64_t op2;

-

-   op1.high = op1.low = 42;

-   op2 = 100;

-   op3 = make_undefined();

-   test(op1, op2, op3);  // no complaint; op3 is just copied around

-}

-

-int main ()

-{

-   op1_undefined();

-   op2_undefined();

-   op3_undefined();

-

-   return 0;

-}

diff --git a/memcheck/tests/s390x/cds.stderr.exp b/memcheck/tests/s390x/cds.stderr.exp

deleted file mode 100644

index e72de94c8..000000000

--- a/memcheck/tests/s390x/cds.stderr.exp

+++ /dev/null

@@ -1,10 +0,0 @@

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (cds.c:17)

-   by 0x........: op1_undefined (cds.c:50)

-   by 0x........: main (cds.c:77)

-

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (cds.c:17)

-   by 0x........: op2_undefined (cds.c:61)

-   by 0x........: main (cds.c:78)

-

diff --git a/memcheck/tests/s390x/cds.stdout.exp b/memcheck/tests/s390x/cds.stdout.exp

deleted file mode 100644

index e69de29bb..000000000

diff --git a/memcheck/tests/s390x/cds.vgtest b/memcheck/tests/s390x/cds.vgtest

deleted file mode 100644

index 5195887e2..000000000

--- a/memcheck/tests/s390x/cds.vgtest

+++ /dev/null

@@ -1,2 +0,0 @@

-prog: cds

-vgopts: -q

diff --git a/memcheck/tests/s390x/cs.c b/memcheck/tests/s390x/cs.c

deleted file mode 100644

index 9a298cef9..000000000

--- a/memcheck/tests/s390x/cs.c

+++ /dev/null

@@ -1,32 +0,0 @@

-#include <stdint.h>

-#include <stdio.h>

-#include <string.h>

-

-void 

-test(int32_t op1_init, int32_t op2_init, int32_t op3_init)

-{

-   register int32_t op1 asm("8") = op1_init;

-   register int32_t op3 asm("9") = op3_init;

-   

-   int32_t op2 = op2_init;

-   int cc = 1; 

-

-   __asm__ volatile (

-           "cs      8,9,%1\n\t"

-           "ipm     %0\n\t"

-           "srl     %0,28\n\t"

-           : "=d" (cc), "+Q" (op2), "+d"(op1), "+d"(op3)

-           : 

-           : "cc");

-}

-

-int main ()

-{

-   int op1, op2, op3;

-

-   test(op1, 0x10000000, 0x12345678);   // complaint

-   test(0x10000000, op2, 0x12345678);   // complaint

-   test(0x10000000, 0x01000000, op3);   // no complaint

-

-   return 0;

-}

diff --git a/memcheck/tests/s390x/cs.stderr.exp b/memcheck/tests/s390x/cs.stderr.exp

deleted file mode 100644

index e45dc99cd..000000000

--- a/memcheck/tests/s390x/cs.stderr.exp

+++ /dev/null

@@ -1,8 +0,0 @@

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (cs.c:14)

-   by 0x........: main (cs.c:27)

-

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (cs.c:14)

-   by 0x........: main (cs.c:28)

-

diff --git a/memcheck/tests/s390x/cs.stdout.exp b/memcheck/tests/s390x/cs.stdout.exp

deleted file mode 100644

index e69de29bb..000000000

diff --git a/memcheck/tests/s390x/cs.vgtest b/memcheck/tests/s390x/cs.vgtest

deleted file mode 100644

index 323cce80c..000000000

--- a/memcheck/tests/s390x/cs.vgtest

+++ /dev/null

@@ -1,2 +0,0 @@

-prog: cs

-vgopts: -q

diff --git a/memcheck/tests/s390x/csg.c b/memcheck/tests/s390x/csg.c

deleted file mode 100644

index 7f9d8c88e..000000000

--- a/memcheck/tests/s390x/csg.c

+++ /dev/null

@@ -1,32 +0,0 @@

-#include <stdint.h>

-#include <stdio.h>

-#include <string.h>

-

-void 

-test(int64_t op1_init, int64_t op2_init, int64_t op3_init)

-{

-   register int64_t op1 asm("8") = op1_init;

-   register int64_t op3 asm("9") = op3_init;

-   

-   int64_t op2 = op2_init;

-   int cc = 1; 

-

-   __asm__ volatile (

-           "csg     8,9,%1\n\t"

-           "ipm     %0\n\t"

-           "srl     %0,28\n\t"

-           : "=d" (cc), "+Q" (op2), "+d"(op1), "+d"(op3)

-           : 

-           : "cc");

-}

-

-int main ()

-{

-   int64_t op1, op2, op3;

-

-   test(op1, 0x1000000000000000ull, 0x1234567887654321ull);  // complaint

-   test(0x1000000000000000ull, op2, 0x1234567887654321ull);  // complaint

-   test(0x1000000000000000ull, 0x1000000000000000ull, op3);  // no complaint

-

-   return 0;

-}

diff --git a/memcheck/tests/s390x/csg.stderr.exp b/memcheck/tests/s390x/csg.stderr.exp

deleted file mode 100644

index fda2021ce..000000000

--- a/memcheck/tests/s390x/csg.stderr.exp

+++ /dev/null

@@ -1,8 +0,0 @@

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (csg.c:14)

-   by 0x........: main (csg.c:27)

-

-Conditional jump or move depends on uninitialised value(s)

-   at 0x........: test (csg.c:14)

-   by 0x........: main (csg.c:28)

-

diff --git a/memcheck/tests/s390x/csg.stdout.exp b/memcheck/tests/s390x/csg.stdout.exp

deleted file mode 100644

index e69de29bb..000000000

diff --git a/memcheck/tests/s390x/csg.vgtest b/memcheck/tests/s390x/csg.vgtest

deleted file mode 100644

index 6de75c1d6..000000000

--- a/memcheck/tests/s390x/csg.vgtest

+++ /dev/null

@@ -1,2 +0,0 @@

-prog: csg

-vgopts: -q

commit 18ddcc47c951427efd3b790ba2481159b9bd1598

Author: Andreas Arnez <arnez@linux.ibm.com>

Date:   Wed Apr 7 16:48:29 2021 +0200

    s390x: Support "expensive" comparisons Iop_ExpCmpNE32/64

    Add support for Iop_ExpCmpNE32 and Iop_ExpCmpNE64 in the s390x instruction

    selector.  Handle them exactly like the "inexpensive" variants Iop_CmpNE32

    and Iop_CmpNE64.

diff --git a/VEX/priv/host_s390_isel.c b/VEX/priv/host_s390_isel.c

index 2000ec224..5f79280c0 100644

--- a/VEX/priv/host_s390_isel.c

+++ b/VEX/priv/host_s390_isel.c

@@ -3611,6 +3611,8 @@ s390_isel_cc(ISelEnv *env, IRExpr *cond)

       case Iop_CmpNE32:

       case Iop_CmpNE64:

+      case Iop_ExpCmpNE32:

+      case Iop_ExpCmpNE64:

       case Iop_CasCmpNE32:

       case Iop_CasCmpNE64:

          result = S390_CC_NE;

commit 5db3f929c43bf46f4707178706cfe90f43acdd19

Author: Andreas Arnez <arnez@linux.ibm.com>

Date:   Wed Apr 7 12:30:20 2021 +0200

    s390x: Add convenience function mkV128()

    Provide mkV128() as a short-hand notation for creating a vector constant from

    a bit pattern, similar to other such functions like mkU64().

diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c

index 339377007..7d54cb551 100644

--- a/VEX/priv/guest_s390_toIR.c

+++ b/VEX/priv/guest_s390_toIR.c

@@ -376,6 +376,13 @@ mkU64(ULong value)

    return IRExpr_Const(IRConst_U64(value));

 }

+/* Create an expression node for a 128-bit vector constant */

+static __inline__ IRExpr *

+mkV128(UShort value)

+{

+   return IRExpr_Const(IRConst_V128(value));

+}

+

 /* Create an expression node for a 32-bit floating point constant

    whose value is given by a bit pattern. */

 static __inline__ IRExpr *

@@ -16249,7 +16256,7 @@ s390_irgen_VLGV(UChar r1, IRTemp op2addr, UChar v3, UChar m4)

 static const HChar *

 s390_irgen_VGBM(UChar v1, UShort i2, UChar m3 __attribute__((unused)))

 {

-   put_vr_qw(v1, IRExpr_Const(IRConst_V128(i2)));

+   put_vr_qw(v1, mkV128(i2));

    return "vgbm";

 }

@@ -18160,11 +18167,11 @@ s390_irgen_VSUM(UChar v1, UChar v2, UChar v3, UChar m4)

    switch(type) {

    case Ity_I8:

       sum = unop(Iop_PwAddL16Ux8, unop(Iop_PwAddL8Ux16, get_vr_qw(v2)));

-      mask = IRExpr_Const(IRConst_V128(0b0001000100010001));

+      mask = mkV128(0b0001000100010001);

       break;

    case Ity_I16:

       sum = unop(Iop_PwAddL16Ux8, get_vr_qw(v2));

-      mask = IRExpr_Const(IRConst_V128(0b0011001100110011));

+      mask = mkV128(0b0011001100110011);

       break;

    default:

       vpanic("s390_irgen_VSUM: invalid type ");

@@ -18185,11 +18192,11 @@ s390_irgen_VSUMG(UChar v1, UChar v2, UChar v3, UChar m4)

    switch(type) {

    case Ity_I16:

       sum = unop(Iop_PwAddL32Ux4, unop(Iop_PwAddL16Ux8, get_vr_qw(v2)));

-      mask = IRExpr_Const(IRConst_V128(0b0000001100000011));

+      mask = mkV128(0b0000001100000011);

       break;

    case Ity_I32:

       sum = unop(Iop_PwAddL32Ux4, get_vr_qw(v2));

-      mask = IRExpr_Const(IRConst_V128(0b0000111100001111));

+      mask = mkV128(0b0000111100001111);

       break;

    default:

       vpanic("s390_irgen_VSUMG: invalid type ");

@@ -18210,11 +18217,11 @@ s390_irgen_VSUMQ(UChar v1, UChar v2, UChar v3, UChar m4)

    switch(type) {

    case Ity_I32:

       sum = unop(Iop_PwAddL64Ux2, unop(Iop_PwAddL32Ux4, get_vr_qw(v2)));

-      mask = IRExpr_Const(IRConst_V128(0b0000000000001111));

+      mask = mkV128(0b0000000000001111);

       break;

    case Ity_I64:

       sum = unop(Iop_PwAddL64Ux2, get_vr_qw(v2));

-      mask = IRExpr_Const(IRConst_V128(0b0000000011111111));

+      mask = mkV128(0b0000000011111111);

       break;

    default:

       vpanic("s390_irgen_VSUMQ: invalid type ");

@@ -18943,8 +18950,8 @@ s390_irgen_VFCx(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5, UChar m6,

          assign(cond, binop(Iop_CmpEQ32, mkexpr(result), mkU32(cmp)));

       }

       put_vr_qw(v1, mkite(mkexpr(cond),

-                          IRExpr_Const(IRConst_V128(0xffff)),

-                          IRExpr_Const(IRConst_V128(0))));

+                          mkV128(0xffff),

+                          mkV128(0)));

       if (s390_vr_is_cs_set(m6)) {

          IRTemp cc = newTemp(Ity_I64);

          assign(cc, mkite(mkexpr(cond), mkU64(0), mkU64(3)));

commit e78bd78d3043729033b426218ab8c6dae9c51e96

Author: Andreas Arnez <arnez@linux.ibm.com>

Date:   Thu Mar 18 18:01:10 2021 +0100

    Bug 434296 - s390x: Rework IR conversion of VSTRC, VFAE, and VFEE

    The z/Architecture instructions "vector string range compare" (VSTRC),

    "vector find any element equal" (VFAE), and "vector find element

    equal" (VFEE) are each implemented with a dirty helper that executes the

    instruction.  Unfortunately this approach leads to memcheck false

    positives, because these instructions may yield a defined result even if

    parts of the input vectors are undefined.  There are multiple ways this

    can happen: Wherever the flags in the fourth operand to VSTRC indicate

    "match always" or "match never", the corresponding elements in the third

    operand don't affect the result.  The same is true for the elements

    following the first zero-element in the second operand if the ZS flag is

    set, or for the elements following the first matching element, if any.

    Re-implement the instructions without dirty helpers and transform into

    lengthy IR instead.

diff --git a/VEX/priv/guest_s390_defs.h b/VEX/priv/guest_s390_defs.h

index 905429015..49b6cd5dd 100644

--- a/VEX/priv/guest_s390_defs.h

+++ b/VEX/priv/guest_s390_defs.h

@@ -265,11 +265,8 @@ typedef enum {

    S390_VEC_OP_INVALID = 0,

    S390_VEC_OP_VPKS,

    S390_VEC_OP_VPKLS,

-   S390_VEC_OP_VFAE,

-   S390_VEC_OP_VFEE,

    S390_VEC_OP_VFENE,

    S390_VEC_OP_VISTR,

-   S390_VEC_OP_VSTRC,

    S390_VEC_OP_VCEQ,

    S390_VEC_OP_VTM,

    S390_VEC_OP_VGFM,

diff --git a/VEX/priv/guest_s390_helpers.c b/VEX/priv/guest_s390_helpers.c

index b71b621ae..63d2e8ce5 100644

--- a/VEX/priv/guest_s390_helpers.c

+++ b/VEX/priv/guest_s390_helpers.c

@@ -2538,11 +2538,8 @@ s390x_dirtyhelper_vec_op(VexGuestS390XState *guest_state,

       {0x00, 0x00}, /* invalid */

       [S390_VEC_OP_VPKS]  = {0xe7, 0x97},

       [S390_VEC_OP_VPKLS] = {0xe7, 0x95},

-      [S390_VEC_OP_VFAE]  = {0xe7, 0x82},

-      [S390_VEC_OP_VFEE]  = {0xe7, 0x80},

       [S390_VEC_OP_VFENE] = {0xe7, 0x81},

       [S390_VEC_OP_VISTR] = {0xe7, 0x5c},

-      [S390_VEC_OP_VSTRC] = {0xe7, 0x8a},

       [S390_VEC_OP_VCEQ]  = {0xe7, 0xf8},

       [S390_VEC_OP_VTM]   = {0xe7, 0xd8},

       [S390_VEC_OP_VGFM]  = {0xe7, 0xb4},

@@ -2630,8 +2627,6 @@ s390x_dirtyhelper_vec_op(VexGuestS390XState *guest_state,

    case S390_VEC_OP_VPKS:

    case S390_VEC_OP_VPKLS:

-   case S390_VEC_OP_VFAE:

-   case S390_VEC_OP_VFEE:

    case S390_VEC_OP_VFENE:

    case S390_VEC_OP_VCEQ:

    case S390_VEC_OP_VGFM:

@@ -2645,7 +2640,6 @@ s390x_dirtyhelper_vec_op(VexGuestS390XState *guest_state,

       the_insn.VRR.m5 = d->m5;

       break;

-   case S390_VEC_OP_VSTRC:

    case S390_VEC_OP_VGFMA:

    case S390_VEC_OP_VMAH:

    case S390_VEC_OP_VMALH:

diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c

index 7d54cb551..26a947813 100644

--- a/VEX/priv/guest_s390_toIR.c

+++ b/VEX/priv/guest_s390_toIR.c

@@ -17156,90 +17156,205 @@ s390_irgen_PPNO(UChar r1, UChar r2)

    return "ppno";

 }

-static const HChar *

-s390_irgen_VFAE(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5)

-{

-   IRDirty* d;

-   IRTemp cc = newTemp(Ity_I64);

+enum s390_VStrX {

+   s390_VStrX_VSTRC,

+   s390_VStrX_VFAE,

+   s390_VStrX_VFEE

+};

-   /* Check for specification exception */

-   vassert(m4 < 3);

+#define S390_VEC_OP3(m, op0, op1, op2)                                  \

+   (m) == 0 ? op0 : (m) == 1 ? op1 : (m) == 2 ? op2 : Iop_INVALID;

-   s390x_vec_op_details_t details = { .serialized = 0ULL };

-   details.op = S390_VEC_OP_VFAE;

-   details.v1 = v1;

-   details.v2 = v2;

-   details.v3 = v3;

-   details.m4 = m4;

-   details.m5 = m5;

-

-   d = unsafeIRDirty_1_N(cc, 0, "s390x_dirtyhelper_vec_op",

-                         &s390x_dirtyhelper_vec_op,

-                         mkIRExprVec_2(IRExpr_GSPTR(),

-                                       mkU64(details.serialized)));

+/* Helper function for transforming VSTRC, VFAE, or VFEE.  These instructions

+   share much of the same logic. */

+static void

+s390_irgen_VStrX(UChar v1, UChar v2, UChar v3, UChar v4, UChar m5,

+                 UChar m6, enum s390_VStrX which_insn)

+{

+   IRTemp op2 = newTemp(Ity_V128);

+   IRTemp op3 = newTemp(Ity_V128);

+   IRExpr* tmp;

+   IRExpr* match = NULL;

+   UChar bitwidth = 8 << m5;

+   UChar n_elem = 16 >> m5;

+   IROp sub_op = S390_VEC_OP3(m5, Iop_Sub8x16, Iop_Sub16x8, Iop_Sub32x4);

+   IROp sar_op = S390_VEC_OP3(m5, Iop_SarN8x16, Iop_SarN16x8, Iop_SarN32x4);

+   IROp shl_op = S390_VEC_OP3(m5, Iop_ShlN8x16, Iop_ShlN16x8, Iop_ShlN32x4);

+   IROp dup_op = S390_VEC_OP3(m5, Iop_Dup8x16, Iop_Dup16x8, Iop_Dup32x4);

+   IROp cmpeq_op = S390_VEC_OP3(m5, Iop_CmpEQ8x16,

+                                    Iop_CmpEQ16x8, Iop_CmpEQ32x4);

+   IROp cmpgt_op = S390_VEC_OP3(m5, Iop_CmpGT8Ux16,

+                                    Iop_CmpGT16Ux8, Iop_CmpGT32Ux4);

+   IROp getelem_op = S390_VEC_OP3(m5, Iop_GetElem8x16,

+                                      Iop_GetElem16x8, Iop_GetElem32x4);

+

+   assign(op2, get_vr_qw(v2));

+   assign(op3, get_vr_qw(v3));

+

+   switch (which_insn) {

+

+   case s390_VStrX_VSTRC: {

+      IRTemp op4 = newTemp(Ity_V128);

+      assign(op4, get_vr_qw(v4));

+

+      /* Mask off insignificant range boundaries from op3, i.e., all those for

+         which the corresponding field in op4 has all or no bits set ("match

+         always" / "match never"). */

+      IRTemp bounds = newTemp(Ity_V128);

+      tmp = unop(Iop_NotV128,

+                 binop(cmpeq_op, mkV128(0),

+                       binop(sar_op,

+                             binop(sub_op,

+                                   binop(sar_op, mkexpr(op4),

+                                         mkU8(bitwidth - 3)),

+                                   mkV128(-1)),

+                             mkU8(1))));

+      assign(bounds, binop(Iop_AndV128, mkexpr(op3), tmp));

+

+      IRTemp flags_eq = newTemp(Ity_V128);

+      IRTemp flags_lt = newTemp(Ity_V128);

+      IRTemp flags_gt = newTemp(Ity_V128);

+      assign(flags_eq, binop(sar_op, mkexpr(op4), mkU8(bitwidth - 1)));

+      assign(flags_lt, binop(sar_op, binop(shl_op, mkexpr(op4), mkU8(1)),

+                             mkU8(bitwidth - 1)));

+      assign(flags_gt, binop(sar_op, binop(shl_op, mkexpr(op4), mkU8(2)),

+                             mkU8(bitwidth - 1)));

+

+      for (UChar idx = 0; idx < n_elem; idx += 2) {

+         /* Match according to the even/odd pairs in op3 and op4 at idx */

+         IRTemp part[2];

+

+         for (UChar j = 0; j < 2; j++) {

+            IRTemp a = newTemp(Ity_V128);

+            assign(a, unop(dup_op,

+                           binop(getelem_op, mkexpr(bounds), mkU8(idx + j))));

+

+            IRExpr* m[] = {

+               binop(cmpeq_op, mkexpr(op2), mkexpr(a)),

+               binop(cmpgt_op, mkexpr(a), mkexpr(op2)),

+               binop(cmpgt_op, mkexpr(op2), mkexpr(a))

+            };

+            IRExpr* f[] = {

+               unop(dup_op, binop(getelem_op, mkexpr(flags_eq), mkU8(idx + j))),

+               unop(dup_op, binop(getelem_op, mkexpr(flags_lt), mkU8(idx + j))),

+               unop(dup_op, binop(getelem_op, mkexpr(flags_gt), mkU8(idx + j)))

+            };

+            part[j] = newTemp(Ity_V128);

+            assign(part[j], binop(Iop_OrV128,

+                                  binop(Iop_OrV128,

+                                        binop(Iop_AndV128, f[0], m[0]),

+                                        binop(Iop_AndV128, f[1], m[1])),

+                                  binop(Iop_AndV128, f[2], m[2])));

+         }

+         tmp = binop(Iop_AndV128, mkexpr(part[0]), mkexpr(part[1]));

+         match = idx == 0 ? tmp : binop(Iop_OrV128, match, tmp);

+      }

+      break;

+   }

-   d->nFxState = 3;

-   vex_bzero(&d->fxState, sizeof(d->fxState));

-   d->fxState[0].fx     = Ifx_Read;

-   d->fxState[0].offset = S390X_GUEST_OFFSET(guest_v0) + v2 * sizeof(V128);

-   d->fxState[0].size   = sizeof(V128);

-   d->fxState[1].fx     = Ifx_Read;

-   d->fxState[1].offset = S390X_GUEST_OFFSET(guest_v0) + v3 * sizeof(V128);

-   d->fxState[1].size   = sizeof(V128);

-   d->fxState[2].fx     = Ifx_Write;

-   d->fxState[2].offset = S390X_GUEST_OFFSET(guest_v0) + v1 * sizeof(V128);

-   d->fxState[2].size   = sizeof(V128);

+   case s390_VStrX_VFAE:

+      for (UChar idx = 0; idx < n_elem; idx++) {

+         IRTemp a = newTemp(Ity_V128);

+         assign(a, binop(cmpeq_op, mkexpr(op2),

+                         unop(dup_op,

+                              binop(getelem_op, mkexpr(op3), mkU8(idx)))));

+         match = idx == 0 ? mkexpr(a) : binop(Iop_OrV128, match, mkexpr(a));

+      }

+      break;

-   stmt(IRStmt_Dirty(d));

+   case s390_VStrX_VFEE:

+      match = binop(cmpeq_op, mkexpr(op2), mkexpr(op3));

+      break;

-   if (s390_vr_is_cs_set(m5)) {

-      s390_cc_set(cc);

+   default:

+      vpanic("s390_irgen_VStrX: unknown insn");

    }

-   return "vfae";

-}

+   /* Invert first intermediate result if requested */

+   if (m6 & 8)

+      match = unop(Iop_NotV128, match);

-static const HChar *

-s390_irgen_VFEE(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5)

-{

-   IRDirty* d;

-   IRTemp cc = newTemp(Ity_I64);

+   IRTemp inter1 = newTemp(Ity_V128);

+   IRTemp inter2 = newTemp(Ity_V128);

+   IRTemp accu = newTemp(Ity_V128);

+   assign(inter1, match);

-   /* Check for specification exception */

-   vassert(m4 < 3);

-   vassert((m5 & 0b1100) == 0);

+   /* Determine second intermediate and accumulated result */

+   if (s390_vr_is_zs_set(m6)) {

+      assign(inter2, binop(cmpeq_op, mkexpr(op2), mkV128(0)));

+      assign(accu, binop(Iop_OrV128, mkexpr(inter1), mkexpr(inter2)));

+   } else {

+      assign(inter2, mkV128(0));

+      assign(accu, mkexpr(inter1));

+   }

-   s390x_vec_op_details_t details = { .serialized = 0ULL };

-   details.op = S390_VEC_OP_VFEE;

-   details.v1 = v1;

-   details.v2 = v2;

-   details.v3 = v3;

-   details.m4 = m4;

-   details.m5 = m5;

+   IRTemp accu0 = newTemp(Ity_I64);

+   IRTemp is_match0 = newTemp(Ity_I1);

+   IRTemp mismatch_bits = newTemp(Ity_I64);

-   d = unsafeIRDirty_1_N(cc, 0, "s390x_dirtyhelper_vec_op",

-                         &s390x_dirtyhelper_vec_op,

-                         mkIRExprVec_2(IRExpr_GSPTR(),

-                                       mkU64(details.serialized)));

+   assign(accu0, unop(Iop_V128HIto64, mkexpr(accu)));

+   assign(is_match0, binop(Iop_ExpCmpNE64, mkexpr(accu0), mkU64(0)));

+   assign(mismatch_bits, unop(Iop_ClzNat64,

+                              mkite(mkexpr(is_match0), mkexpr(accu0),

+                                    unop(Iop_V128to64, mkexpr(accu)))));

-   d->nFxState = 3;

-   vex_bzero(&d->fxState, sizeof(d->fxState));

-   d->fxState[0].fx     = Ifx_Read;

-   d->fxState[0].offset = S390X_GUEST_OFFSET(guest_v0) + v2 * sizeof(V128);

-   d->fxState[0].size   = sizeof(V128);

-   d->fxState[1].fx     = Ifx_Read;

-   d->fxState[1].offset = S390X_GUEST_OFFSET(guest_v0) + v3 * sizeof(V128);

-   d->fxState[1].size   = sizeof(V128);

-   d->fxState[2].fx     = Ifx_Write;

-   d->fxState[2].offset = S390X_GUEST_OFFSET(guest_v0) + v1 * sizeof(V128);

-   d->fxState[2].size   = sizeof(V128);

+   if (m6 & 4) {

+      put_vr_qw(v1, mkexpr(inter1));

+   } else {

+      /* Determine byte position of first match */

+      tmp = binop(Iop_Add64,

+                  binop(Iop_Shr64, mkexpr(mismatch_bits), mkU8(3)),

+                  mkite(mkexpr(is_match0), mkU64(0), mkU64(8)));

+      put_vr_qw(v1, binop(Iop_64HLtoV128, tmp, mkU64(0)));

+   }

-   stmt(IRStmt_Dirty(d));

+   if (s390_vr_is_cs_set(m6)) {

+      /* Set condition code depending on...

+                   zero found

+                      n  y

+                    +------

+         match    n | 3  0

+          found   y | 1  2   */

-   if (s390_vr_is_cs_set(m5)) {

+      IRTemp cc = newTemp(Ity_I64);

+

+      tmp = binop(Iop_Shr64,

+                  mkite(mkexpr(is_match0),

+                        unop(Iop_V128HIto64, mkexpr(inter1)),

+                        unop(Iop_V128to64, mkexpr(inter1))),

+                  unop(Iop_64to8,

+                       binop(Iop_Sub64, mkU64(63), mkexpr(mismatch_bits))));

+      tmp = binop(Iop_Shl64, tmp, mkU8(1));

+      if (s390_vr_is_zs_set(m6)) {

+         tmp = binop(Iop_Xor64, tmp,

+                     mkite(binop(Iop_ExpCmpNE64, mkU64(0),

+                                 binop(Iop_Or64,

+                                       unop(Iop_V128HIto64, mkexpr(inter2)),

+                                       unop(Iop_V128to64, mkexpr(inter2)))),

+                           mkU64(0),

+                           mkU64(3)));

+      } else {

+         tmp = binop(Iop_Xor64, tmp, mkU64(3));

+      }

+      assign(cc, tmp);

       s390_cc_set(cc);

    }