From: Julian Seward Date: Thu, 11 Jan 2018 17:20:27 +0000 (+0100) Subject: Bug 385408 - s390x: z13 vector "support" instructions not implemented. Patch from... X-Git-Tag: VALGRIND_3_14_0~184 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=f1a49eeb427caf42e7af2da2b91198e55c6f33b2;p=thirdparty%2Fvalgrind.git Bug 385408 - s390x: z13 vector "support" instructions not implemented. Patch from Vadim Barkov (vbrkov@gmail.com). (from bug 385408 comment 0): Valgrind currently lacks support for the z/Architecture vector "support" instructions introduced with z13. These are documented in the z/Architecture Principles of Operation, Eleventh Edition (March, 2015), chapter 21: "Vector Overview and Support Instructions". --- diff --git a/.gitignore b/.gitignore index 1410eb1105..bb2cf9d255 100644 --- a/.gitignore +++ b/.gitignore @@ -1857,6 +1857,7 @@ /none/tests/s390x/rxsbg /none/tests/s390x/fixbr /none/tests/s390x/popcnt +/none/tests/s390x/vector # /none/tests/scripts/ /none/tests/scripts/*.dSYM diff --git a/VEX/priv/guest_s390_defs.h b/VEX/priv/guest_s390_defs.h index 8ba6d94319..d3dede7a81 100644 --- a/VEX/priv/guest_s390_defs.h +++ b/VEX/priv/guest_s390_defs.h @@ -80,7 +80,8 @@ ULong s390x_dirtyhelper_STCKF(ULong *addr); ULong s390x_dirtyhelper_STCKE(ULong *addr); ULong s390x_dirtyhelper_STFLE(VexGuestS390XState *guest_state, ULong *addr); void s390x_dirtyhelper_CUxy(UChar *addr, ULong data, ULong num_bytes); - +ULong s390x_dirtyhelper_vec_binop(VexGuestS390XState *guest_state, ULong opcode, + ULong v1, ULong v2); ULong s390_do_cu12_cu14_helper1(UInt byte1, UInt etf3_and_m3_is_1); ULong s390_do_cu12_helper2(UInt byte1, UInt byte2, UInt byte3, UInt byte4, ULong stuff); @@ -254,6 +255,46 @@ UInt s390_calculate_cond(ULong mask, ULong op, ULong dep1, ULong dep2, /* Last target instruction for the EX helper */ extern ULong last_execute_target; +/*------------------------------------------------------------*/ +/*--- Vector helpers. ---*/ +/*------------------------------------------------------------*/ + +/* Vector operatons which can change condition code */ +enum { + S390_CC_VEC_INVALID = 0, + S390_CC_VEC_VPKS = 1, + S390_CC_VEC_VPKLS = 2, + S390_CC_VEC_LAST = 3 // supposed to be the last element in enum +} s390x_cc_vec_binop; + +/* Create an "object" which contain information about vector operation + and it's element size. Used for passing data to dirtyhelper with one argument. +*/ +#define s390x_cc_vec_opcode(op, elem_size) ( ((op) << 3) | ((elem_size) & 0x07)) + +/* Extract operation from opcode created with "s390x_cc_vec_opcode" macro */ +#define s390x_cc_vec_get_op(opcode) ((opcode) >> 3) + +/* Extract operation from opcode created with "s390x_cc_vec_opcode" macro */ +#define s390x_cc_vec_get_elem_size(opcode) ((opcode) & 0x07) + + +/* Macro definitions for opcodes that are not generally available. + + The values to be encoded in those fields must be integer values in + hexadecimal notation without a leading 0x. + E.g. VRX_VXBD(e7, 1, 0, 3, 0000, 0, 06) is equal to "vl %%v1, 0(%%r3)\n\t" +*/ +#define VRX_VXBD(op1, v1, x2, b2, d2, rxb, op2) \ + ".short 0x" #op1 #v1 #x2 "\n\t .int 0x" #b2 #d2 "0" #rxb #op2 "\n\t" +#define VRR_VVVMM(op1, v1, v2, v3, m5, m4, rxb, op2) \ + ".short 0x" #op1 #v1 #v2 "\n\t .int 0x" #v3 "0" #m5 "0" #m4 #rxb #op2 "\n\t" + +#define VL(v1, x2, b2, d2, rxb) VRX_VXBD(e7, v1, x2, b2, d2, rxb, 06) +#define VPKS(v1, v2, v3, m4, m5, rxb) VRR_VVVMM(e7, v1, v2, v3, m5, m4, rxb, 97) +#define VPKLS(v1, v2, v3, m4, m5, rxb) VRR_VVVMM(e7, v1, v2, v3, m5, m4, rxb, 95) + + /*---------------------------------------------------------------*/ /*--- end guest_s390_defs.h ---*/ /*---------------------------------------------------------------*/ diff --git a/VEX/priv/guest_s390_helpers.c b/VEX/priv/guest_s390_helpers.c index aacd833b54..77772fe104 100644 --- a/VEX/priv/guest_s390_helpers.c +++ b/VEX/priv/guest_s390_helpers.c @@ -68,26 +68,48 @@ LibVEX_GuestS390X_initialise(VexGuestS390XState *state) state->guest_a15 = 0; /*------------------------------------------------------------*/ -/*--- Initialise fpr registers ---*/ +/*--- Initialise vr registers ---*/ /*------------------------------------------------------------*/ - state->guest_f0 = 0; - state->guest_f1 = 0; - state->guest_f2 = 0; - state->guest_f3 = 0; - state->guest_f4 = 0; - state->guest_f5 = 0; - state->guest_f6 = 0; - state->guest_f7 = 0; - state->guest_f8 = 0; - state->guest_f9 = 0; - state->guest_f10 = 0; - state->guest_f11 = 0; - state->guest_f12 = 0; - state->guest_f13 = 0; - state->guest_f14 = 0; - state->guest_f15 = 0; - +#define VRZERO(vr) \ + do { \ + vr.w64[0] = vr.w64[1] = 0ULL; \ + } while(0); + + VRZERO(state->guest_v0) + VRZERO(state->guest_v1) + VRZERO(state->guest_v2) + VRZERO(state->guest_v3) + VRZERO(state->guest_v4) + VRZERO(state->guest_v5) + VRZERO(state->guest_v6) + VRZERO(state->guest_v7) + VRZERO(state->guest_v8) + VRZERO(state->guest_v9) + VRZERO(state->guest_v10) + VRZERO(state->guest_v11) + VRZERO(state->guest_v12) + VRZERO(state->guest_v13) + VRZERO(state->guest_v14) + VRZERO(state->guest_v15) + VRZERO(state->guest_v16) + VRZERO(state->guest_v17) + VRZERO(state->guest_v18) + VRZERO(state->guest_v19) + VRZERO(state->guest_v20) + VRZERO(state->guest_v21) + VRZERO(state->guest_v22) + VRZERO(state->guest_v23) + VRZERO(state->guest_v24) + VRZERO(state->guest_v25) + VRZERO(state->guest_v26) + VRZERO(state->guest_v27) + VRZERO(state->guest_v28) + VRZERO(state->guest_v29) + VRZERO(state->guest_v30) + VRZERO(state->guest_v31) + +#undef VRZERO /*------------------------------------------------------------*/ /*--- Initialise gpr registers ---*/ /*------------------------------------------------------------*/ @@ -1187,6 +1209,23 @@ decode_bfp_rounding_mode(UInt irrm) psw >> 28; /* cc */ \ }) +/* This macro believes that arguments' addresses are in GPR1 and GPR2. + We use %%v16, %%v17 and %%v18 to avoid side effects in FPRs. +*/ +#define S390_CC_FOR_V128_BINOP(insn) \ +({ \ + /* VL(v1, x2, b2, d2, rxb) */ \ + __asm__ volatile ( \ + VL(1, 0, 1, 000, 8) \ + VL(2, 0, 2, 000, 8) \ + insn \ + "ipm %[psw]\n\t" \ + : [psw] "=d"(psw) \ + : "d"(arg1), "d"(arg2) \ + : "cc", "v16", "v17", "v18"); \ + psw >> 28; /* cc */ \ +}) + /* Convert an IRRoundingMode value to s390_dfp_round_t */ #if defined(VGA_s390x) static s390_dfp_round_t @@ -2434,6 +2473,58 @@ missed: return NULL; } +/*------------------------------------------------------------*/ +/*--- Dirty helper for vector instructions ---*/ +/*------------------------------------------------------------*/ + +#if defined(VGA_s390x) +ULong +s390x_dirtyhelper_vec_binop(VexGuestS390XState *guest_state, ULong opcode, + ULong v1, ULong v2) +{ + UInt psw; + UInt elem_size = s390x_cc_vec_get_elem_size(opcode); + UInt op = s390x_cc_vec_get_op(opcode); + /* S390_CC_FOR_V128_BINOP relies on exatly this GPRs numbers and names. */ + register ULong arg1 asm("1") = (ULong) &((&guest_state->guest_v0)[v1]); + register ULong arg2 asm("2") = (ULong) &((&guest_state->guest_v0)[v2]); + + switch(op) { + case S390_CC_VEC_VPKS: + /* VPKS(v1, v2, v3, m4, m5, rxb) */ + switch(elem_size) { + case 1: return S390_CC_FOR_V128_BINOP(VPKS(3, 1, 2, 1, 1, e)); + case 2: return S390_CC_FOR_V128_BINOP(VPKS(3, 1, 2, 2, 1, e)); + case 3: return S390_CC_FOR_V128_BINOP(VPKS(3, 1, 2, 3, 1, e)); + default: vassert(0); + } + + case S390_CC_VEC_VPKLS: + /* VPKLS(v1, v2, v3, m4, m5, rxb) */ + switch(elem_size) { + case 1: return S390_CC_FOR_V128_BINOP(VPKLS(3, 1, 2, 1, 1, e)); + case 2: return S390_CC_FOR_V128_BINOP(VPKLS(3, 1, 2, 2, 1, e)); + case 3: return S390_CC_FOR_V128_BINOP(VPKLS(3, 1, 2, 3, 1, e)); + default: vassert(0); + } + + default: + vex_printf("operation = %d\n", op); + vpanic("s390x_dirtyhelper_vec_binop: unknown operation"); + } + + return 0; +} + +#else + +ULong +s390x_dirtyhelper_vec_binop(VexGuestS390XState *guest_state, ULong opcode, + ULong v1, ULong v2) +{ return 0; } + +#endif + /*---------------------------------------------------------------*/ /*--- end guest_s390_helpers.c ---*/ /*---------------------------------------------------------------*/ diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c index b36b85e918..cca684a8e2 100644 --- a/VEX/priv/guest_s390_toIR.c +++ b/VEX/priv/guest_s390_toIR.c @@ -919,27 +919,29 @@ get_ar_w0(UInt archreg) /*--- fpr registers ---*/ /*------------------------------------------------------------*/ -/* Return the guest state offset of a fpr register. */ +/* Return the guest state offset of a fpr register. + FPRs are maped to first doubleword of VRs. +*/ static UInt fpr_offset(UInt archreg) { static const UInt offset[16] = { - S390X_GUEST_OFFSET(guest_f0), - S390X_GUEST_OFFSET(guest_f1), - S390X_GUEST_OFFSET(guest_f2), - S390X_GUEST_OFFSET(guest_f3), - S390X_GUEST_OFFSET(guest_f4), - S390X_GUEST_OFFSET(guest_f5), - S390X_GUEST_OFFSET(guest_f6), - S390X_GUEST_OFFSET(guest_f7), - S390X_GUEST_OFFSET(guest_f8), - S390X_GUEST_OFFSET(guest_f9), - S390X_GUEST_OFFSET(guest_f10), - S390X_GUEST_OFFSET(guest_f11), - S390X_GUEST_OFFSET(guest_f12), - S390X_GUEST_OFFSET(guest_f13), - S390X_GUEST_OFFSET(guest_f14), - S390X_GUEST_OFFSET(guest_f15), + S390X_GUEST_OFFSET(guest_v0), + S390X_GUEST_OFFSET(guest_v1), + S390X_GUEST_OFFSET(guest_v2), + S390X_GUEST_OFFSET(guest_v3), + S390X_GUEST_OFFSET(guest_v4), + S390X_GUEST_OFFSET(guest_v5), + S390X_GUEST_OFFSET(guest_v6), + S390X_GUEST_OFFSET(guest_v7), + S390X_GUEST_OFFSET(guest_v8), + S390X_GUEST_OFFSET(guest_v9), + S390X_GUEST_OFFSET(guest_v10), + S390X_GUEST_OFFSET(guest_v11), + S390X_GUEST_OFFSET(guest_v12), + S390X_GUEST_OFFSET(guest_v13), + S390X_GUEST_OFFSET(guest_v14), + S390X_GUEST_OFFSET(guest_v15), }; vassert(archreg < 16); @@ -1511,6 +1513,396 @@ get_fpc_w0(void) } +/*------------------------------------------------------------*/ +/*--- vr registers ---*/ +/*------------------------------------------------------------*/ + +/* Return the guest state offset of a vr register. */ +static UInt +vr_offset(UInt archreg) +{ + static const UInt offset[32] = { + S390X_GUEST_OFFSET(guest_v0), + S390X_GUEST_OFFSET(guest_v1), + S390X_GUEST_OFFSET(guest_v2), + S390X_GUEST_OFFSET(guest_v3), + S390X_GUEST_OFFSET(guest_v4), + S390X_GUEST_OFFSET(guest_v5), + S390X_GUEST_OFFSET(guest_v6), + S390X_GUEST_OFFSET(guest_v7), + S390X_GUEST_OFFSET(guest_v8), + S390X_GUEST_OFFSET(guest_v9), + S390X_GUEST_OFFSET(guest_v10), + S390X_GUEST_OFFSET(guest_v11), + S390X_GUEST_OFFSET(guest_v12), + S390X_GUEST_OFFSET(guest_v13), + S390X_GUEST_OFFSET(guest_v14), + S390X_GUEST_OFFSET(guest_v15), + S390X_GUEST_OFFSET(guest_v16), + S390X_GUEST_OFFSET(guest_v17), + S390X_GUEST_OFFSET(guest_v18), + S390X_GUEST_OFFSET(guest_v19), + S390X_GUEST_OFFSET(guest_v20), + S390X_GUEST_OFFSET(guest_v21), + S390X_GUEST_OFFSET(guest_v22), + S390X_GUEST_OFFSET(guest_v23), + S390X_GUEST_OFFSET(guest_v24), + S390X_GUEST_OFFSET(guest_v25), + S390X_GUEST_OFFSET(guest_v26), + S390X_GUEST_OFFSET(guest_v27), + S390X_GUEST_OFFSET(guest_v28), + S390X_GUEST_OFFSET(guest_v29), + S390X_GUEST_OFFSET(guest_v30), + S390X_GUEST_OFFSET(guest_v31), + }; + + vassert(archreg < 32); + + return offset[archreg]; +} + +/* Return the guest state offset of quadword of a vr register. */ +static UInt +vr_qw_offset(UInt archreg) +{ + return vr_offset(archreg) + 0; +} + +/* Write quadword of a vr to the guest state. */ +static void +put_vr_qw(UInt archreg, IRExpr *expr) +{ + vassert(typeOfIRExpr(irsb->tyenv, expr) == Ity_V128); + + stmt(IRStmt_Put(vr_qw_offset(archreg), expr)); +} + +/* Read quadword of a vr register. */ +static IRExpr * +get_vr_qw(UInt archreg) +{ + return IRExpr_Get(vr_qw_offset(archreg), Ity_V128); +} + +/* Return the guest state offset of double word #0 of a gpr register. */ +static UInt +vr_dw0_offset(UInt archreg) +{ + return vr_offset(archreg) + 0; +} + +/* Read doubleword #0 of a vr register. */ +static IRExpr * +get_vr_dw0(UInt archreg) +{ + return IRExpr_Get(vr_dw0_offset(archreg), Ity_I64); +} + +/* Write double word #0 of a vr to the guest state. */ +static void +put_vr_dw0(UInt archreg, IRExpr *expr) +{ + vassert(typeOfIRExpr(irsb->tyenv, expr) == Ity_I64); + + stmt(IRStmt_Put(vr_dw0_offset(archreg), expr)); +} + +/* Return the guest state offset of double word #1 of a gpr register. */ +static UInt +vr_dw1_offset(UInt archreg) +{ + return vr_offset(archreg) + 8; +} + +/* Read doubleword #1 of a vr register. */ +static IRExpr * +get_vr_dw1(UInt archreg) +{ + return IRExpr_Get(vr_dw1_offset(archreg), Ity_I64); +} + +/* Write double word #0 of a vr to the guest state. */ +static void +put_vr_dw1(UInt archreg, IRExpr *expr) +{ + vassert(typeOfIRExpr(irsb->tyenv, expr) == Ity_I64); + + stmt(IRStmt_Put(vr_dw1_offset(archreg), expr)); +} + +/* Return the guest state offset of word #1 of a gpr register. */ +static UInt +vr_w1_offset(UInt archreg) +{ + return vr_offset(archreg) + 4; +} + +/* Return the guest state offset of word #3 of a gpr register. */ +static UInt +vr_w3_offset(UInt archreg) +{ + return vr_offset(archreg) + 12; +} + +/* Read word #1 of a vr register. */ +static IRExpr * +get_vr_w1(UInt archreg) +{ + return IRExpr_Get(vr_w1_offset(archreg), Ity_I32); +} + +/* Read word #3 of a vr register. */ +static IRExpr * +get_vr_w3(UInt archreg) +{ + return IRExpr_Get(vr_w3_offset(archreg), Ity_I32); +} + +/* Return the guest state offset of halfword #3 of a gpr register. */ +static UInt +vr_hw3_offset(UInt archreg) +{ + return vr_offset(archreg) + 6; +} + +/* Read halfword #3 of a vr register. */ +static IRExpr * +get_vr_hw3(UInt archreg) +{ + return IRExpr_Get(vr_hw3_offset(archreg), Ity_I16); +} + +/* Return the guest state offset of halfword #7 of a gpr register. */ +static UInt +vr_hw7_offset(UInt archreg) +{ + return vr_offset(archreg) + 14; +} + +/* Read halfword #7 of a vr register. */ +static IRExpr * +get_vr_hw7(UInt archreg) +{ + return IRExpr_Get(vr_hw7_offset(archreg), Ity_I16); +} + +/* Return the guest state offset of byte #7 of a vr register. */ +static UInt +vr_b7_offset(UInt archreg) +{ + return vr_offset(archreg) + 7; +} + +/* Read byte #7 of a vr register. */ +static IRExpr * +get_vr_b7(UInt archreg) +{ + return IRExpr_Get(vr_b7_offset(archreg), Ity_I8); +} + +/* Return the guest state offset of byte #15 of a vr register. */ +static UInt +vr_b15_offset(UInt archreg) +{ + return vr_offset(archreg) + 15; +} + +/* Read byte #15 of a vr register. */ +static IRExpr * +get_vr_b15(UInt archreg) +{ + return IRExpr_Get(vr_b15_offset(archreg), Ity_I8); +} + +/* Determine IRType by instruction's m3 field */ +static IRType +s390_vr_get_type(const UChar m) +{ + static const IRType results[] = {Ity_I8, Ity_I16, Ity_I32, Ity_I64, Ity_V128}; + if (m > 4) { + vex_printf("s390_vr_get_type: m=%x\n", m); + vpanic("s390_vr_get_type: reserved m value"); + } + + return results[m]; +} + +/* Return the guest state offset of element with type's size and given index + of a vr register. +*/ +static UInt +s390_vr_offset_by_index(UInt archreg,IRType type, UChar index) +{ + switch (type) { + case Ity_I8: + if(index > 15) { + goto invalidIndex; + } + return vr_offset(archreg) + sizeof(UChar) * index; + + case Ity_I16: + if(index > 7) { + goto invalidIndex; + } + return vr_offset(archreg) + sizeof(UShort) * index; + + case Ity_I32: + if(index > 3) { + goto invalidIndex; + } + return vr_offset(archreg) + sizeof(UInt) * index; + + case Ity_I64: + if(index > 1) { + goto invalidIndex; + } + return vr_offset(archreg) + sizeof(ULong) * index; + case Ity_V128: + if(index == 0) { + return vr_qw_offset(archreg); + } else { + goto invalidIndex; + } + default: + vpanic("s390_vr_offset_by_index: unknown type"); + } + + invalidIndex: + vex_printf("s390_vr_offset_by_index: index = %d ; type = ", index); + ppIRType(type); + vpanic("s390_vr_offset_by_index: invalid index for given type"); +} + +/* Write type sized element to indexed part of vr to the guest state. */ +static void +put_vr(UInt archreg, IRType type, UChar index, IRExpr *expr) +{ + UInt offset = s390_vr_offset_by_index(archreg, type, index); + vassert(typeOfIRExpr(irsb->tyenv, expr) == type); + + stmt(IRStmt_Put(offset, expr)); +} + +/* Read type sized part specified by index of a vr register. */ +static IRExpr * +get_vr(UInt archreg, IRType type, UChar index) +{ + UInt offset = s390_vr_offset_by_index(archreg, type, index); + return IRExpr_Get(offset, type); +} + +/* Calculates vr index according to instruction's rxb field + and position of vr in instruction. + Index of first argument must be 1 (not zero) */ +static UChar +s390_vr_getVRindex(UChar v,UChar argNumber, UChar rxb) +{ + vassert(argNumber > 0 && argNumber <= 4); + vassert(rxb < 16); + return v | (((rxb) << (++argNumber)) & 0b00010000); +} + +static void +s390_vr_fill(UChar v1, IRExpr *o2) +{ + IRType o2type = typeOfIRExpr(irsb->tyenv, o2); + switch (o2type) { + case Ity_I8: + put_vr_qw(v1, unop(Iop_Dup8x16, o2)); + break; + case Ity_I16: + put_vr_qw(v1, unop(Iop_Dup16x8, o2)); + break; + case Ity_I32: + put_vr_qw(v1, unop(Iop_Dup32x4, o2)); + break; + case Ity_I64: + put_vr_dw0(v1, o2); + put_vr_dw1(v1, o2); + break; + default: + ppIRType(o2type); + vpanic("s390_vr_fill: invalid IRType"); + } +} + +/* Returns Ity_I32 number of bytes till block boundary specified by m */ +static IRExpr* +s390_getCountToBlockBoundary(IRTemp op2addr, UChar m) +{ + IRTemp boundary = newTemp(Ity_I32); + IRTemp sixteen = newTemp(Ity_I32); + IRTemp divisionResult = newTemp(Ity_I64); + IRTemp mod_result = newTemp(Ity_I32); + IRTemp output = newTemp(Ity_I32); + + switch (m) { + case 0: assign(boundary, mkU32(64)); break; + case 1: assign(boundary, mkU32(128)); break; + case 2: assign(boundary, mkU32(256)); break; + case 3: assign(boundary, mkU32(512)); break; + case 4: assign(boundary, mkU32(1024)); break; + case 5: assign(boundary, mkU32(2048)); break; + case 6: assign(boundary, mkU32(4096)); break; + default: + vex_printf("m = %d\n", m); + vpanic("s390_getCountToBlockBoundary: invalid m"); + } + assign(sixteen, mkU32(16)); + assign(divisionResult, + binop(Iop_DivModU64to32, mkexpr(op2addr), mkexpr(boundary))); + assign(mod_result, + binop(Iop_Sub32,mkexpr(boundary), + unop(Iop_64HIto32, mkexpr(divisionResult)))); + + assign(output, + mkite(binop(Iop_CmpLE32U, mkexpr(sixteen), mkexpr(mod_result)), + mkexpr(sixteen), + mkexpr(mod_result) + )); + + return mkexpr(output); +} + +/* Helper macro for s390_vr_loadWithLength */ +#define s390_vr_loadWithLength_process(elem) \ + put_vr_qw(v1, triop(Iop_SetElem8x16,\ + get_vr_qw(v1), mkU8(elem),\ + mkite(binop(Iop_CmpLE32U, mkU32(elem), mkexpr(maxIndexToLoad)),\ + load(Ity_I8, binop(Iop_Add64, mkexpr(addr), mkU64(elem))),\ + mkU8(0x00)\ + )\ + )\ + ) + +/* Load bytes into v1. + maxIndex specifies max index to load and must be Ity_I32. + If maxIndex > 16, all 16 bytes are loaded. + All bytes after maxIndex are zeroed. */ +static void s390_vr_loadWithLength(UChar v1, IRTemp addr, IRExpr *maxIndex) +{ + IRTemp maxIndexToLoad = newTemp(Ity_I32); + + assign(maxIndexToLoad, maxIndex); + + s390_vr_loadWithLength_process(0); + s390_vr_loadWithLength_process(1); + s390_vr_loadWithLength_process(2); + s390_vr_loadWithLength_process(3); + s390_vr_loadWithLength_process(4); + s390_vr_loadWithLength_process(5); + s390_vr_loadWithLength_process(6); + s390_vr_loadWithLength_process(7); + s390_vr_loadWithLength_process(8); + s390_vr_loadWithLength_process(9); + s390_vr_loadWithLength_process(10); + s390_vr_loadWithLength_process(11); + s390_vr_loadWithLength_process(12); + s390_vr_loadWithLength_process(13); + s390_vr_loadWithLength_process(14); + s390_vr_loadWithLength_process(15); +} + /*------------------------------------------------------------*/ /*--- Rounding modes ---*/ /*------------------------------------------------------------*/ @@ -2588,90 +2980,448 @@ s390_format_SIL_RDU(const HChar *(*irgen)(UShort i2, IRTemp op1addr), s390_disasm(ENC3(MNM, UDXB, UINT), mnm, d1, 0, b1, i2); } +static void +s390_format_VRX_VRRD(const HChar *(*irgen)(UChar v1, IRTemp op2addr), + UChar v1, UChar x2, UChar b2, UShort d2, UChar rxb) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } -/*------------------------------------------------------------*/ -/*--- Build IR for opcodes ---*/ -/*------------------------------------------------------------*/ - -static const HChar * -s390_irgen_AR(UChar r1, UChar r2) -{ - IRTemp op1 = newTemp(Ity_I32); - IRTemp op2 = newTemp(Ity_I32); - IRTemp result = newTemp(Ity_I32); + assign(op2addr, binop(Iop_Add64, binop(Iop_Add64, mkU64(d2), + b2 != 0 ? get_gpr_dw0(b2) : mkU64(0)), x2 != 0 ? get_gpr_dw0(x2) : + mkU64(0))); - assign(op1, get_gpr_w1(r1)); - assign(op2, get_gpr_w1(r2)); - assign(result, binop(Iop_Add32, mkexpr(op1), mkexpr(op2))); - s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_32, op1, op2); - put_gpr_w1(r1, mkexpr(result)); + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, op2addr); - return "ar"; + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC3(MNM, VR, UDXB), mnm, v1, d2, x2, b2); } -static const HChar * -s390_irgen_AGR(UChar r1, UChar r2) + +static void +s390_format_VRX_VRRDM(const HChar *(*irgen)(UChar v1, IRTemp op2addr, UChar m3), + UChar v1, UChar x2, UChar b2, UShort d2, UChar m3, UChar rxb) { - IRTemp op1 = newTemp(Ity_I64); - IRTemp op2 = newTemp(Ity_I64); - IRTemp result = newTemp(Ity_I64); + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); - assign(op1, get_gpr_dw0(r1)); - assign(op2, get_gpr_dw0(r2)); - assign(result, binop(Iop_Add64, mkexpr(op1), mkexpr(op2))); - s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op1, op2); - put_gpr_dw0(r1, mkexpr(result)); + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } - return "agr"; + assign(op2addr, binop(Iop_Add64, binop(Iop_Add64, mkU64(d2), + b2 != 0 ? get_gpr_dw0(b2) : mkU64(0)), x2 != 0 ? get_gpr_dw0(x2) : + mkU64(0))); + + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, op2addr, m3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC3(MNM, VR, UDXB), mnm, v1, d2, x2, b2); } -static const HChar * -s390_irgen_AGFR(UChar r1, UChar r2) + +static void +s390_format_VRR_VV(const HChar *(*irgen)(UChar v1, UChar v2), + UChar v1, UChar v2, UChar rxb) { - IRTemp op1 = newTemp(Ity_I64); - IRTemp op2 = newTemp(Ity_I64); - IRTemp result = newTemp(Ity_I64); + const HChar *mnm; - assign(op1, get_gpr_dw0(r1)); - assign(op2, unop(Iop_32Sto64, get_gpr_w1(r2))); - assign(result, binop(Iop_Add64, mkexpr(op1), mkexpr(op2))); - s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op1, op2); - put_gpr_dw0(r1, mkexpr(result)); + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } - return "agfr"; + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + mnm = irgen(v1, v2); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC3(MNM, VR, VR), mnm, v1, v2); } -static const HChar * -s390_irgen_ARK(UChar r3, UChar r1, UChar r2) + +static void +s390_format_VRR_VVV(const HChar *(*irgen)(UChar v1, UChar v2, UChar v3), + UChar v1, UChar v2, UChar v3, UChar rxb) { - IRTemp op2 = newTemp(Ity_I32); - IRTemp op3 = newTemp(Ity_I32); - IRTemp result = newTemp(Ity_I32); + const HChar *mnm; - assign(op2, get_gpr_w1(r2)); - assign(op3, get_gpr_w1(r3)); - assign(result, binop(Iop_Add32, mkexpr(op2), mkexpr(op3))); - s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_32, op2, op3); - put_gpr_w1(r1, mkexpr(result)); + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } - return "ark"; + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + v3 = s390_vr_getVRindex(v3, 3, rxb); + mnm = irgen(v1, v2, v3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, VR, VR), mnm, v1, v2, v3); } -static const HChar * -s390_irgen_AGRK(UChar r3, UChar r1, UChar r2) + +static void +s390_format_VRR_VVVM(const HChar *(*irgen)(UChar v1, UChar v2, UChar v3, UChar m4), + UChar v1, UChar v2, UChar v3, UChar m4, UChar rxb) { - IRTemp op2 = newTemp(Ity_I64); - IRTemp op3 = newTemp(Ity_I64); - IRTemp result = newTemp(Ity_I64); + const HChar *mnm; - assign(op2, get_gpr_dw0(r2)); - assign(op3, get_gpr_dw0(r3)); - assign(result, binop(Iop_Add64, mkexpr(op2), mkexpr(op3))); - s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op2, op3); - put_gpr_dw0(r1, mkexpr(result)); + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } - return "agrk"; + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + v3 = s390_vr_getVRindex(v3, 3, rxb); + mnm = irgen(v1, v2, v3, m4); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC5(MNM, VR, VR, VR, UINT), mnm, v1, v2, v3, m4); +} + + +static void +s390_format_VRR_VVVMM(const HChar *(*irgen)(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5), + UChar v1, UChar v2, UChar v3, UChar m4, UChar m5, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + v3 = s390_vr_getVRindex(v3, 3, rxb); + mnm = irgen(v1, v2, v3, m4, m5); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC6(MNM, VR, VR, VR, UINT, UINT), mnm, v1, v2, v3, m4, m5); +} + + +static void +s390_format_VRR_VVVV(const HChar *(*irgen)(UChar v1, UChar v2, UChar v3, UChar v4), + UChar v1, UChar v2, UChar v3, UChar v4, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + v3 = s390_vr_getVRindex(v3, 3, rxb); + v4 = s390_vr_getVRindex(v4, 4, rxb); + mnm = irgen(v1, v2, v3, v4); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC5(MNM, VR, VR, VR, VR), mnm, v1, v2, v3, v4); +} + + +static void +s390_format_VRR_VRR(const HChar *(*irgen)(UChar v1, UChar r2, UChar r3), + UChar v1, UChar r2, UChar r3, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, r2, r3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, GPR, GPR), mnm, v1, r2, r3); +} + + +static void +s390_format_VRR_VVM(const HChar *(*irgen)(UChar v1, UChar v2, UChar m3), + UChar v1, UChar v2, UChar m3, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + mnm = irgen(v1, v2, m3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, VR, UINT), mnm, v1, v2, m3); +} + + +static void +s390_format_VRI_VIM(const HChar *(*irgen)(UChar v1, UShort i2, UChar m3), + UChar v1, UShort i2, UChar m3, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, i2, m3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, UINT, UINT), mnm, v1, i2, m3); +} + + +static void +s390_format_VRI_VVIM(const HChar *(*irgen)(UChar v1, UChar v3, UShort i2, UChar m4), + UChar v1, UChar v3, UShort i2, UChar m4, UChar rxb) +{ + const HChar *mnm; + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v3 = s390_vr_getVRindex(v3, 2, rxb); + mnm = irgen(v1, v3, i2, m4); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC5(MNM, VR, VR, UINT, UINT), mnm, v1, v3, i2, m4); +} + + +static void +s390_format_VRS_RRDVM(const HChar *(*irgen)(UChar r1, IRTemp op2addr, UChar v3, + UChar m4), UChar r1, UChar b2, UShort d2, UChar v3, + UChar m4, UChar rxb) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + assign(op2addr, binop(Iop_Add64, mkU64(d2), b2 != 0 ? get_gpr_dw0(b2) : + mkU64(0))); + + v3 = s390_vr_getVRindex(v3, 2, rxb); + mnm = irgen(r1, op2addr, v3, m4); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC5(MNM, GPR, UDXB, VR, UINT), mnm, r1, d2, 0, b2, v3, m4); +} + + +static void +s390_format_VRS_VRDV(const HChar *(*irgen)(UChar v1, IRTemp op2addr, UChar v3), + UChar v1, UChar b2, UShort d2, UChar v3, UChar rxb) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + assign(op2addr, binop(Iop_Add64, mkU64(d2), b2 != 0 ? get_gpr_dw0(b2) : + mkU64(0))); + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v3 = s390_vr_getVRindex(v3, 2, rxb); + mnm = irgen(v1, op2addr, v3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, UDXB, VR), mnm, v1, d2, 0, b2, v3); +} + + +static void +s390_format_VRS_VRRDM(const HChar *(*irgen)(UChar v1, IRTemp op2addr, UChar r3, + UChar m4), + UChar v1, UChar b2, UShort d2, UChar r3, UChar m4, UChar rxb) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + assign(op2addr, binop(Iop_Add64, mkU64(d2), b2 != 0 ? get_gpr_dw0(b2) : + mkU64(0))); + + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, op2addr, r3, m4); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC5(MNM, VR, GPR, UDXB, UINT), mnm, v1, r3, d2, 0, b2, m4); +} + + +static void +s390_format_VRS_VRRD(const HChar *(*irgen)(UChar v1, IRTemp op2addr, UChar r3), + UChar v1, UChar b2, UShort d2, UChar r3, UChar rxb) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + assign(op2addr, binop(Iop_Add64, mkU64(d2), b2 != 0 ? get_gpr_dw0(b2) : + mkU64(0))); + + v1 = s390_vr_getVRindex(v1, 1, rxb); + mnm = irgen(v1, op2addr, r3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, GPR, UDXB), mnm, v1, r3, d2, 0, b2); +} + + +static void +s390_format_VRV_VVRDMT(const HChar *(*irgen)(UChar v1, IRTemp op2addr, UChar m3), + UChar v1, UChar v2, UChar b2, UShort d2, UChar m3, UChar rxb, + IRType type) +{ + const HChar *mnm; + IRTemp op2addr = newTemp(Ity_I64); + + if (! s390_host_has_vx) { + emulation_failure(EmFail_S390X_vx); + return; + } + + v1 = s390_vr_getVRindex(v1, 1, rxb); + v2 = s390_vr_getVRindex(v2, 2, rxb); + + vassert(type == Ity_I32 || type == Ity_I64); + IRExpr *x2; + if(type == Ity_I32) { + x2 = unop(Iop_32Uto64, get_vr(v2, type, m3)); + } else { + x2 = get_vr(v2, type, m3); + } + + assign(op2addr, binop(Iop_Add64, binop(Iop_Add64, mkU64(d2), + b2 != 0 ? get_gpr_dw0(b2) : mkU64(0)), x2)); + + mnm = irgen(v1, op2addr, m3); + + if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) + s390_disasm(ENC4(MNM, VR, UDVB, UINT), mnm, v1, d2, v2, b2, m3); +} + + +/*------------------------------------------------------------*/ +/*--- Build IR for opcodes ---*/ +/*------------------------------------------------------------*/ + +static const HChar * +s390_irgen_AR(UChar r1, UChar r2) +{ + IRTemp op1 = newTemp(Ity_I32); + IRTemp op2 = newTemp(Ity_I32); + IRTemp result = newTemp(Ity_I32); + + assign(op1, get_gpr_w1(r1)); + assign(op2, get_gpr_w1(r2)); + assign(result, binop(Iop_Add32, mkexpr(op1), mkexpr(op2))); + s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_32, op1, op2); + put_gpr_w1(r1, mkexpr(result)); + + return "ar"; +} + +static const HChar * +s390_irgen_AGR(UChar r1, UChar r2) +{ + IRTemp op1 = newTemp(Ity_I64); + IRTemp op2 = newTemp(Ity_I64); + IRTemp result = newTemp(Ity_I64); + + assign(op1, get_gpr_dw0(r1)); + assign(op2, get_gpr_dw0(r2)); + assign(result, binop(Iop_Add64, mkexpr(op1), mkexpr(op2))); + s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op1, op2); + put_gpr_dw0(r1, mkexpr(result)); + + return "agr"; +} + +static const HChar * +s390_irgen_AGFR(UChar r1, UChar r2) +{ + IRTemp op1 = newTemp(Ity_I64); + IRTemp op2 = newTemp(Ity_I64); + IRTemp result = newTemp(Ity_I64); + + assign(op1, get_gpr_dw0(r1)); + assign(op2, unop(Iop_32Sto64, get_gpr_w1(r2))); + assign(result, binop(Iop_Add64, mkexpr(op1), mkexpr(op2))); + s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op1, op2); + put_gpr_dw0(r1, mkexpr(result)); + + return "agfr"; +} + +static const HChar * +s390_irgen_ARK(UChar r3, UChar r1, UChar r2) +{ + IRTemp op2 = newTemp(Ity_I32); + IRTemp op3 = newTemp(Ity_I32); + IRTemp result = newTemp(Ity_I32); + + assign(op2, get_gpr_w1(r2)); + assign(op3, get_gpr_w1(r3)); + assign(result, binop(Iop_Add32, mkexpr(op2), mkexpr(op3))); + s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_32, op2, op3); + put_gpr_w1(r1, mkexpr(result)); + + return "ark"; +} + +static const HChar * +s390_irgen_AGRK(UChar r3, UChar r1, UChar r2) +{ + IRTemp op2 = newTemp(Ity_I64); + IRTemp op3 = newTemp(Ity_I64); + IRTemp result = newTemp(Ity_I64); + + assign(op2, get_gpr_dw0(r2)); + assign(op3, get_gpr_dw0(r3)); + assign(result, binop(Iop_Add64, mkexpr(op2), mkexpr(op3))); + s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op2, op3); + put_gpr_dw0(r1, mkexpr(result)); + + return "agrk"; } static const HChar * @@ -14136,33 +14886,846 @@ s390_irgen_ECAG(UChar r1, UChar r3 __attribute__((unused)), IRTemp op2addr) return "ecag"; } +static const HChar * +s390_irgen_VL(UChar v1, IRTemp op2addr) +{ + put_vr_qw(v1, load(Ity_V128, mkexpr(op2addr))); -/* New insns are added here. - If an insn is contingent on a facility being installed also - check whether the list of supported facilities in function - s390x_dirtyhelper_STFLE needs updating */ - -/*------------------------------------------------------------*/ -/*--- Build IR for special instructions ---*/ -/*------------------------------------------------------------*/ + return "vl"; +} -static void -s390_irgen_client_request(void) +static const HChar * +s390_irgen_VLR(UChar v1, UChar v2) { - if (0) - vex_printf("%%R3 = client_request ( %%R2 )\n"); + put_vr_qw(v1, get_vr_qw(v2)); - Addr64 next = guest_IA_curr_instr + S390_SPECIAL_OP_PREAMBLE_SIZE - + S390_SPECIAL_OP_SIZE; + return "vlr"; +} - dis_res->jk_StopHere = Ijk_ClientReq; - dis_res->whatNext = Dis_StopHere; +static const HChar * +s390_irgen_VST(UChar v1, IRTemp op2addr) +{ + store(mkexpr(op2addr), get_vr_qw(v1)); - put_IA(mkaddr_expr(next)); + return "vst"; } -static void -s390_irgen_guest_NRADDR(void) +static const HChar * +s390_irgen_VLREP(UChar v1, IRTemp op2addr, UChar m3) +{ + IRType o2type = s390_vr_get_type(m3); + IRExpr* o2 = load(o2type, mkexpr(op2addr)); + s390_vr_fill(v1, o2); + return "vlrep"; +} + +static const HChar * +s390_irgen_VLEB(UChar v1, IRTemp op2addr, UChar m3) +{ + IRExpr* o2 = load(Ity_I8, mkexpr(op2addr)); + put_vr(v1, Ity_I8, m3, o2); + + return "vleb"; +} + +static const HChar * +s390_irgen_VLEH(UChar v1, IRTemp op2addr, UChar m3) +{ + IRExpr* o2 = load(Ity_I16, mkexpr(op2addr)); + put_vr(v1, Ity_I16, m3, o2); + + return "vleh"; +} + +static const HChar * +s390_irgen_VLEF(UChar v1, IRTemp op2addr, UChar m3) +{ + IRExpr* o2 = load(Ity_I32, mkexpr(op2addr)); + put_vr(v1, Ity_I32, m3, o2); + + return "vlef"; +} + +static const HChar * +s390_irgen_VLEG(UChar v1, IRTemp op2addr, UChar m3) +{ + IRExpr* o2 = load(Ity_I64, mkexpr(op2addr)); + put_vr(v1, Ity_I64, m3, o2); + + return "vleg"; +} + +static const HChar * +s390_irgen_VLEIB(UChar v1, UShort i2, UChar m3) +{ + IRExpr* o2 = unop(Iop_16to8, mkU16(i2)); + put_vr(v1, Ity_I8, m3, o2); + + return "vleib"; +} + +static const HChar * +s390_irgen_VLEIH(UChar v1, UShort i2, UChar m3) +{ + IRExpr* o2 = mkU16(i2); + put_vr(v1, Ity_I16, m3, o2); + + return "vleih"; +} + +static const HChar * +s390_irgen_VLEIF(UChar v1, UShort i2, UChar m3) +{ + IRExpr* o2 = unop(Iop_16Sto32, mkU16(i2)); + put_vr(v1, Ity_I32, m3, o2); + + return "vleif"; +} + +static const HChar * +s390_irgen_VLEIG(UChar v1, UShort i2, UChar m3) +{ + IRExpr* o2 = unop(Iop_16Sto64, mkU16(i2)); + put_vr(v1, Ity_I64, m3, o2); + + return "vleig"; +} + +static const HChar * +s390_irgen_VLGV(UChar r1, IRTemp op2addr, UChar v3, UChar m4) +{ + IRType o2type = s390_vr_get_type(m4); + IRExpr* index = unop(Iop_64to8, binop(Iop_And64, mkexpr(op2addr), mkU64(0xf))); + IRExpr* o2; + IRExpr* result; + switch (o2type) { + case Ity_I8: + o2 = binop(Iop_GetElem8x16, get_vr_qw(v3), index); + result = unop(Iop_8Uto64, o2); + break; + case Ity_I16: + o2 = binop(Iop_GetElem16x8, get_vr_qw(v3), index); + result = unop(Iop_16Uto64, o2); + break; + case Ity_I32: + o2 = binop(Iop_GetElem32x4, get_vr_qw(v3), index); + result = unop(Iop_32Uto64, o2); + break; + case Ity_I64: + result = binop(Iop_GetElem64x2, get_vr_qw(v3), index); + break; + default: + ppIRType(o2type); + vpanic("s390_irgen_VLGV: unknown o2type"); + } + + put_gpr_dw0(r1, result); + return "vlgv"; +} + +static const HChar * +s390_irgen_VGBM(UChar v1, UShort i2, UChar m3 __attribute__((unused))) +{ + put_vr_qw(v1, IRExpr_Const(IRConst_V128(i2))); + + return "vgbm"; +} + +static const HChar * +s390_irgen_VGM(UChar v1, UShort i2, UChar m3) +{ + UChar from = (i2 & 0xff00) >> 8; + UChar to = (i2 & 0x00ff); + ULong value = 0UL; + IRType type = s390_vr_get_type(m3); + vassert(from <= to); + + UChar maxIndex = 0; + switch (type) { + case Ity_I8: + maxIndex = 7; + break; + case Ity_I16: + maxIndex = 15; + break; + case Ity_I32: + maxIndex = 31; + break; + case Ity_I64: + maxIndex = 63; + break; + default: + vpanic("s390_irgen_VGM: unknown type"); + } + + for(UChar index = from; index <= to; index++) { + value |= (1ULL << (maxIndex - index)); + } + + IRExpr *fillValue; + switch (type) { + case Ity_I8: + fillValue = mkU8(value); + break; + case Ity_I16: + fillValue = mkU16(value); + break; + case Ity_I32: + fillValue = mkU32(value); + break; + case Ity_I64: + fillValue = mkU64(value); + break; + default: + vpanic("s390_irgen_VGM: unknown type"); + } + + s390_vr_fill(v1, fillValue); + return "vgm"; +} + +static const HChar * +s390_irgen_VLLEZ(UChar v1, IRTemp op2addr, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + IRExpr* op2 = load(type, mkexpr(op2addr)); + IRExpr* op2as64bit; + switch (type) { + case Ity_I8: + op2as64bit = unop(Iop_8Uto64, op2); + break; + case Ity_I16: + op2as64bit = unop(Iop_16Uto64, op2); + break; + case Ity_I32: + op2as64bit = unop(Iop_32Uto64, op2); + break; + case Ity_I64: + op2as64bit = op2; + break; + default: + vpanic("s390_irgen_VLLEZ: unknown type"); + } + + put_vr_dw0(v1, op2as64bit); + put_vr_dw1(v1, mkU64(0)); + return "vllez"; +} + +static const HChar * +s390_irgen_VGEF(UChar v1, IRTemp op2addr, UChar m3) +{ + put_vr(v1, Ity_I32, m3, load(Ity_I32, mkexpr(op2addr))); + return "vgef"; +} + +static const HChar * +s390_irgen_VGEG(UChar v1, IRTemp op2addr, UChar m3) +{ + put_vr(v1, Ity_I64, m3, load(Ity_I64, mkexpr(op2addr))); + return "vgeg"; +} + +static const HChar * +s390_irgen_VLM(UChar v1, IRTemp op2addr, UChar v3) +{ + IRExpr* current = mkexpr(op2addr); + vassert(v3 >= v1); + vassert(v3 - v1 <= 16); + + for(UChar vr = v1; vr <= v3; vr++) { + IRExpr* next = binop(Iop_Add64, current, mkU64(16)); + put_vr_qw(vr, load(Ity_V128, current)); + current = next; + } + + return "vlm"; +} + +static const HChar * +s390_irgen_VLVGP(UChar v1, UChar r2, UChar r3) +{ + put_vr_dw0(v1, get_gpr_dw0(r2)); + put_vr_dw1(v1, get_gpr_dw0(r3)); + + return "vlvgp"; +} + +static const HChar * +s390_irgen_VLVG(UChar v1, IRTemp op2addr, UChar r3, UChar m4) +{ + IRType type = s390_vr_get_type(m4); + IRExpr* index = unop(Iop_64to8, mkexpr(op2addr)); + IRExpr* vr = get_vr_qw(v1); + IRExpr* operand; + switch (type) { + case Ity_I8: + operand = unop(Iop_64to8, get_gpr_dw0(r3)); + put_vr_qw(v1, triop(Iop_SetElem8x16, vr, index, operand)); + break; + case Ity_I16: + operand = unop(Iop_64to16, get_gpr_dw0(r3)); + put_vr_qw(v1, triop(Iop_SetElem16x8, vr, index, operand)); + break; + case Ity_I32: + operand = unop(Iop_64to32, get_gpr_dw0(r3)); + put_vr_qw(v1, triop(Iop_SetElem32x4, vr, index, operand)); + break; + case Ity_I64: + operand = get_gpr_dw0(r3); + put_vr_qw(v1, triop(Iop_SetElem64x2, vr, index, operand)); + break; + default: + vpanic("s390_irgen_VLVG: unknown type"); + } + + return "vlvg"; +} + +static const HChar * +s390_irgen_VMRH(UChar v1, UChar v2, UChar v3, UChar m4) +{ + IRType type = s390_vr_get_type(m4); + switch (type) { + case Ity_I8: + put_vr_qw(v1, binop(Iop_InterleaveLO8x16, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I16: + put_vr_qw(v1, binop(Iop_InterleaveLO16x8, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I32: + put_vr_qw(v1, binop(Iop_InterleaveLO32x4, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I64: + put_vr_qw(v1, binop(Iop_InterleaveLO64x2, get_vr_qw(v2), get_vr_qw(v3))); + break; + + default: + ppIRType(type); + vpanic("s390_irgen_VMRH: unknown type"); + } + + return "vmrh"; +} + +static const HChar * +s390_irgen_VMRL(UChar v1, UChar v2, UChar v3, UChar m4) +{ + IRType type = s390_vr_get_type(m4); + switch (type) { + case Ity_I8: + put_vr_qw(v1, binop(Iop_InterleaveHI8x16, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I16: + put_vr_qw(v1, binop(Iop_InterleaveHI16x8, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I32: + put_vr_qw(v1, binop(Iop_InterleaveHI32x4, get_vr_qw(v2), get_vr_qw(v3))); + break; + + case Ity_I64: + put_vr_qw(v1, binop(Iop_InterleaveHI64x2, get_vr_qw(v2), get_vr_qw(v3))); + break; + + default: + ppIRType(type); + vpanic("s390_irgen_VMRL: unknown type"); + } + + return "vmrl"; +} + +static const HChar * +s390_irgen_VPK(UChar v1, UChar v2, UChar v3, UChar m4) +{ + IRType type = s390_vr_get_type(m4); + IRExpr* result = NULL; + switch(type) { + case Ity_I16: + result = binop(Iop_NarrowBin16to8x16, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I32: + result = binop(Iop_NarrowBin32to16x8, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I64: + result = binop(Iop_NarrowBin64to32x4, get_vr_qw(v2), get_vr_qw(v3)); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VPK: unknown type"); + } + + put_vr_qw(v1, result); + + return "vpk"; +} + +static const HChar * +s390_irgen_VPERM(UChar v1, UChar v2, UChar v3, UChar v4) +{ + put_vr_qw(v1, triop(Iop_Perm8x16x2, + get_vr_qw(v2), get_vr_qw(v3), get_vr_qw(v4))); + + return "vperm"; +} + +static const HChar * +s390_irgen_VSCEF(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I32, m3)); + return "vscef"; +} + +static const HChar * +s390_irgen_VSCEG(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I64, m3)); + return "vsceg"; +} + +static const HChar * +s390_irgen_VPDI(UChar v1, UChar v2, UChar v3, UChar m4) +{ + /* Theese bits are reserved by specification */ + vassert((m4 & 2) == 0); + vassert((m4 & 8) == 0); + + if((m4 & 4) != 0) + put_vr_dw0(v1, get_vr_dw1(v2)); + else + put_vr_dw0(v1, get_vr_dw0(v2)); + + if((m4 & 1) != 0) + put_vr_dw1(v1, get_vr_dw1(v3)); + else + put_vr_dw1(v1, get_vr_dw0(v3)); + + return "vpdi"; +} + +static const HChar * +s390_irgen_VSEG(UChar v1, UChar v2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + switch(type) { + case Ity_I8: + put_vr_dw0(v1, unop(Iop_8Sto64, get_vr_b7(v2))); + put_vr_dw1(v1, unop(Iop_8Sto64, get_vr_b15(v2))); + break; + case Ity_I16: + put_vr_dw0(v1, unop(Iop_16Sto64, get_vr_hw3(v2))); + put_vr_dw1(v1, unop(Iop_16Sto64, get_vr_hw7(v2))); + break; + case Ity_I32: + put_vr_dw0(v1, unop(Iop_32Sto64, get_vr_w1(v2))); + put_vr_dw1(v1, unop(Iop_32Sto64, get_vr_w3(v2))); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VSEG: unknown type"); + } + + return "vseg"; +} + +static const HChar * +s390_irgen_VSTEB(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I8, m3)); + + return "vsteb"; +} + +static const HChar * +s390_irgen_VSTEH(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I16, m3)); + + return "vsteh"; +} + +static const HChar * +s390_irgen_VSTEF(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I32, m3)); + + return "vstef"; +} + +static const HChar * +s390_irgen_VSTEG(UChar v1, IRTemp op2addr, UChar m3) +{ + store(mkexpr(op2addr), get_vr(v1, Ity_I64, m3)); + + return "vsteg"; +} + +static const HChar * +s390_irgen_VSTM(UChar v1, IRTemp op2addr, UChar v3) +{ + IRExpr* current = mkexpr(op2addr); + vassert(v3 >= v1); + vassert(v3 - v1 <= 16); + + for(UChar vr = v1; vr <= v3; vr++) { + IRExpr* next = binop(Iop_Add64, current, mkU64(16)); + store(current, get_vr_qw(vr)); + current = next; + } + + return "vstm"; +} + +static const HChar * +s390_irgen_VUPH(UChar v1, UChar v2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + switch (type) { + case Ity_I8: + put_vr_qw(v1, unop(Iop_Widen8Sto16x8, get_vr_dw0(v2))); + break; + case Ity_I16: + put_vr_qw(v1, unop(Iop_Widen16Sto32x4, get_vr_dw0(v2))); + break; + case Ity_I32: + put_vr_qw(v1, unop(Iop_Widen32Sto64x2, get_vr_dw0(v2))); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VUPH: unknown type"); + } + + return "vuph"; +} + +static const HChar * +s390_irgen_VUPLH(UChar v1, UChar v2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + switch (type) { + case Ity_I8: + put_vr_qw(v1, unop(Iop_Widen8Uto16x8, get_vr_dw0(v2))); + break; + case Ity_I16: + put_vr_qw(v1, unop(Iop_Widen16Uto32x4, get_vr_dw0(v2))); + break; + case Ity_I32: + put_vr_qw(v1, unop(Iop_Widen32Uto64x2, get_vr_dw0(v2))); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VUPLH: unknown type"); + } + + return "vuplh"; +} + +static const HChar * +s390_irgen_VUPL(UChar v1, UChar v2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + switch (type) { + case Ity_I8: + put_vr_qw(v1, unop(Iop_Widen8Sto16x8, get_vr_dw1(v2))); + break; + case Ity_I16: + put_vr_qw(v1, unop(Iop_Widen16Sto32x4, get_vr_dw1(v2))); + break; + case Ity_I32: + put_vr_qw(v1, unop(Iop_Widen32Sto64x2, get_vr_dw1(v2))); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VUPL: unknown type"); + } + + return "vupl"; +} + +static const HChar * +s390_irgen_VUPLL(UChar v1, UChar v2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + switch (type) { + case Ity_I8: + put_vr_qw(v1, unop(Iop_Widen8Uto16x8, get_vr_dw1(v2))); + break; + case Ity_I16: + put_vr_qw(v1, unop(Iop_Widen16Uto32x4, get_vr_dw1(v2))); + break; + case Ity_I32: + put_vr_qw(v1, unop(Iop_Widen32Uto64x2, get_vr_dw1(v2))); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VUPLL: unknown type"); + } + + return "vupll"; +} + +static const HChar * +s390_irgen_VREP(UChar v1, UChar v3, UShort i2, UChar m4) +{ + IRType type = s390_vr_get_type(m4); + IRExpr* arg = get_vr(v3, type, i2); + s390_vr_fill(v1, arg); + + return "vrep"; +} + +static const HChar * +s390_irgen_VREPI(UChar v1, UShort i2, UChar m3) +{ + IRType type = s390_vr_get_type(m3); + IRExpr *value; + switch (type) { + case Ity_I8: + value = mkU8((UChar)i2); + break; + case Ity_I16: + value = mkU16(i2); + break; + case Ity_I32: + value = unop(Iop_16Sto32, mkU16(i2)); + break; + case Ity_I64: + value = unop(Iop_16Sto64, mkU16(i2)); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VREPI: unknown type"); + } + s390_vr_fill(v1, value); + + return "vrepi"; +} + +static const HChar * +s390_irgen_VPKS(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5) +{ + IRType type = s390_vr_get_type(m4); + IRExpr* result = NULL; + + switch(type) { + case Ity_I16: + result = binop(Iop_QNarrowBin16Sto8Sx16, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I32: + result = binop(Iop_QNarrowBin32Sto16Sx8, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I64: + result = binop(Iop_QNarrowBin64Sto32Sx4, get_vr_qw(v2), get_vr_qw(v3)); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VPKS: unknown type"); + } + + if((m5 & 0x1) != 0) { + IRDirty* d; + IRTemp cc = newTemp(Ity_I64); + ULong opcode = s390x_cc_vec_opcode(S390_CC_VEC_VPKS, m4); + d = unsafeIRDirty_1_N(cc, 0, "s390x_dirtyhelper_vec_binop", + &s390x_dirtyhelper_vec_binop, + mkIRExprVec_4(IRExpr_GSPTR(), mkU64(opcode), + mkU64(v2), mkU64(v3))); + d->nFxState = 2; + 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); + + stmt(IRStmt_Dirty(d)); + s390_cc_thunk_fill(mkU64(S390_CC_OP_SET), + mkexpr(cc), mkU64(0), mkU64(0)); + } + + put_vr_qw(v1, result); + return "vpks"; +} + +static const HChar * +s390_irgen_VPKLS(UChar v1, UChar v2, UChar v3, UChar m4, UChar m5) +{ + IRType type = s390_vr_get_type(m4); + IRExpr* result = NULL; + switch(type) { + case Ity_I16: + result = binop(Iop_QNarrowBin16Uto8Ux16, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I32: + result = binop(Iop_QNarrowBin32Uto16Ux8, get_vr_qw(v2), get_vr_qw(v3)); + break; + case Ity_I64: + result = binop(Iop_QNarrowBin64Uto32Ux4, get_vr_qw(v2), get_vr_qw(v3)); + break; + default: + ppIRType(type); + vpanic("s390_irgen_VPKLS: unknown type"); + } + + if((m5 & 0x1) != 0) { + IRDirty* d; + IRTemp cc = newTemp(Ity_I64); + ULong opcode = s390x_cc_vec_opcode(S390_CC_VEC_VPKLS, m4); + d = unsafeIRDirty_1_N(cc, 0, "s390x_dirtyhelper_vec_binop", + &s390x_dirtyhelper_vec_binop, + mkIRExprVec_4(IRExpr_GSPTR(), mkU64(opcode), + mkU64(v2), mkU64(v3))); + d->nFxState = 2; + 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); + + stmt(IRStmt_Dirty(d)); + s390_cc_thunk_fill(mkU64(S390_CC_OP_SET), + mkexpr(cc), mkU64(0), mkU64(0)); + } + + put_vr_qw(v1, result); + return "vpkls"; +} + +static const HChar * +s390_irgen_VSEL(UChar v1, UChar v2, UChar v3, UChar v4) +{ + IRExpr* vA = get_vr_qw(v3); + IRExpr* vB = get_vr_qw(v2); + IRExpr* vC = get_vr_qw(v4); + + /* result = (vA & ~vC) | (vB & vC) */ + put_vr_qw(v1, + binop(Iop_OrV128, + binop(Iop_AndV128, vA, unop(Iop_NotV128, vC)), + binop(Iop_AndV128, vB, vC) + ) + ); + return "vsel"; +} + +static const HChar * +s390_irgen_VLBB(UChar v1, IRTemp addr, UChar m3) +{ + IRExpr* maxIndex = binop(Iop_Sub32, + s390_getCountToBlockBoundary(addr, m3), + mkU32(1)); + + s390_vr_loadWithLength(v1, addr, maxIndex); + + return "vlbb"; +} + +static const HChar * +s390_irgen_VLL(UChar v1, IRTemp addr, UChar r3) +{ + s390_vr_loadWithLength(v1, addr, get_gpr_w1(r3)); + + return "vll"; +} + +static const HChar * +s390_irgen_VSTL(UChar v1, IRTemp addr, UChar r3) +{ + IRTemp counter = newTemp(Ity_I64); + IRTemp maxIndexToStore = newTemp(Ity_I64); + IRTemp gpr3 = newTemp(Ity_I64); + + assign(gpr3, unop(Iop_32Uto64, get_gpr_w1(r3))); + assign(maxIndexToStore, mkite(binop(Iop_CmpLE64U, + mkexpr(gpr3), + mkU64(16) + ), + mkexpr(gpr3), + mkU64(16) + ) + ); + + assign(counter, get_counter_dw0()); + + store(binop(Iop_Add64, mkexpr(addr), mkexpr(counter)), + binop(Iop_GetElem8x16, get_vr_qw(v1), unop(Iop_64to8, mkexpr(counter)))); + + /* Check for end of field */ + put_counter_dw0(binop(Iop_Add64, mkexpr(counter), mkU64(1))); + iterate_if(binop(Iop_CmpNE64, mkexpr(counter), mkexpr(maxIndexToStore))); + put_counter_dw0(mkU64(0)); + + return "vstl"; +} + +static const HChar * +s390_irgen_VX(UChar v1, UChar v2, UChar v3) +{ + put_vr_qw(v1, binop(Iop_XorV128, get_vr_qw(v2), get_vr_qw(v3))); + + return "vx"; +} + +static const HChar * +s390_irgen_VN(UChar v1, UChar v2, UChar v3) +{ + put_vr_qw(v1, binop(Iop_AndV128, get_vr_qw(v2), get_vr_qw(v3))); + + return "vn"; +} + +static const HChar * +s390_irgen_VO(UChar v1, UChar v2, UChar v3) +{ + put_vr_qw(v1, binop(Iop_OrV128, get_vr_qw(v2), get_vr_qw(v3))); + + return "vo"; +} + +static const HChar * +s390_irgen_VNO(UChar v1, UChar v2, UChar v3) +{ + put_vr_qw(v1, unop(Iop_NotV128, + binop(Iop_OrV128, get_vr_qw(v2), get_vr_qw(v3)))); + + return "vno"; +} + + +/* New insns are added here. + If an insn is contingent on a facility being installed also + check whether the list of supported facilities in function + s390x_dirtyhelper_STFLE needs updating */ + +/*------------------------------------------------------------*/ +/*--- Build IR for special instructions ---*/ +/*------------------------------------------------------------*/ + +static void +s390_irgen_client_request(void) +{ + if (0) + vex_printf("%%R3 = client_request ( %%R2 )\n"); + + Addr64 next = guest_IA_curr_instr + S390_SPECIAL_OP_PREAMBLE_SIZE + + S390_SPECIAL_OP_SIZE; + + dis_res->jk_StopHere = Ijk_ClientReq; + dis_res->whatNext = Dis_StopHere; + + put_IA(mkaddr_expr(next)); +} + +static void +s390_irgen_guest_NRADDR(void) { if (0) vex_printf("%%R3 = guest_NRADDR\n"); @@ -15016,6 +16579,7 @@ s390_decode_4byte_and_irgen(const UChar *bytes) case 0xb927: s390_format_RRE_RR(s390_irgen_LHR, ovl.fmt.RRE.r1, ovl.fmt.RRE.r2); goto ok; case 0xb928: /* PCKMO */ goto unimplemented; + case 0xb929: /* KMA */ goto unimplemented; case 0xb92a: /* KMF */ goto unimplemented; case 0xb92b: /* KMO */ goto unimplemented; case 0xb92c: /* PCC */ goto unimplemented; @@ -15026,6 +16590,7 @@ s390_decode_4byte_and_irgen(const UChar *bytes) ovl.fmt.RRE.r2); goto ok; case 0xb931: s390_format_RRE_RR(s390_irgen_CLGFR, ovl.fmt.RRE.r1, ovl.fmt.RRE.r2); goto ok; + case 0xb93c: /* PPNO */ goto unimplemented; case 0xb93e: /* KIMD */ goto unimplemented; case 0xb93f: /* KLMD */ goto unimplemented; case 0xb941: s390_format_RRF_UURF(s390_irgen_CFDTR, ovl.fmt.RRF2.m3, @@ -15168,6 +16733,7 @@ s390_decode_4byte_and_irgen(const UChar *bytes) ovl.fmt.RRE.r2); goto ok; case 0xb9df: s390_format_RRE_RR(s390_irgen_CLHLR, ovl.fmt.RRE.r1, ovl.fmt.RRE.r2); goto ok; + case 0xb9e0: /* LOCFHR */ goto unimplemented; case 0xb9e1: s390_format_RRE_RR(s390_irgen_POPCNT, ovl.fmt.RRE.r1, ovl.fmt.RRE.r2); goto ok; case 0xb9e2: s390_format_RRF_U0RR(s390_irgen_LOCGR, ovl.fmt.RRF3.r3, @@ -15194,6 +16760,8 @@ s390_decode_4byte_and_irgen(const UChar *bytes) case 0xb9eb: s390_format_RRF_R0RR2(s390_irgen_SLGRK, ovl.fmt.RRF4.r3, ovl.fmt.RRF4.r1, ovl.fmt.RRF4.r2); goto ok; + case 0xb9ec: /* MGRK */ goto unimplemented; + case 0xb9ed: /* MSGRKC */ goto unimplemented; case 0xb9f2: s390_format_RRF_U0RR(s390_irgen_LOCR, ovl.fmt.RRF3.r3, ovl.fmt.RRF3.r1, ovl.fmt.RRF3.r2, S390_XMNM_LOCR); goto ok; @@ -15218,6 +16786,7 @@ s390_decode_4byte_and_irgen(const UChar *bytes) case 0xb9fb: s390_format_RRF_R0RR2(s390_irgen_SLRK, ovl.fmt.RRF4.r3, ovl.fmt.RRF4.r1, ovl.fmt.RRF4.r2); goto ok; + case 0xb9fd: /* MSRKC */ goto unimplemented; } switch ((ovl.value & 0xff000000) >> 24) { @@ -15481,7 +17050,8 @@ s390_decode_6byte_and_irgen(const UChar *bytes) unsigned int x2 : 4; unsigned int b2 : 4; unsigned int d2 : 12; - unsigned int : 8; + unsigned int m3 : 4; + unsigned int : 4; unsigned int op2 : 8; } RXE; struct { @@ -15559,6 +17129,57 @@ s390_decode_6byte_and_irgen(const UChar *bytes) unsigned int d1 : 12; unsigned int i2 : 16; } SIL; + struct { + unsigned int op1 : 8; + unsigned int v1 : 4; + unsigned int x2 : 4; + unsigned int b2 : 4; + unsigned int d2 : 12; + unsigned int m3 : 4; + unsigned int rxb : 4; + unsigned int op2 : 8; + } VRX; + struct { + unsigned int op1 : 8; + unsigned int v1 : 4; + unsigned int v2 : 4; + unsigned int r3 : 4; + unsigned int : 4; + unsigned int m5 : 4; + unsigned int : 4; + unsigned int m4 : 4; + unsigned int rxb : 4; + unsigned int op2 : 8; + } VRR; + struct { + unsigned int op1 : 8; + unsigned int v1 : 4; + unsigned int v3 : 4; + unsigned int i2 : 16; + unsigned int m3 : 4; + unsigned int rxb : 4; + unsigned int op2 : 8; + } VRI; + struct { + unsigned int op1 : 8; + unsigned int v1 : 4; + unsigned int v3 : 4; + unsigned int b2 : 4; + unsigned int d2 : 12; + unsigned int m4 : 4; + unsigned int rxb : 4; + unsigned int op2 : 8; + } VRS; + struct { + unsigned int op1 : 8; + unsigned int v1 : 4; + unsigned int v2 : 4; + unsigned int b2 : 4; + unsigned int d2 : 12; + unsigned int m3 : 4; + unsigned int rxb : 4; + unsigned int op2 : 8; + } VRV; } formats; union { formats fmt; @@ -15689,6 +17310,7 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe3000000002aULL: /* LZRG */ goto unimplemented; case 0xe3000000002eULL: /* CVDG */ goto unimplemented; case 0xe3000000002fULL: s390_format_RXY_RRRD(s390_irgen_STRVG, ovl.fmt.RXY.r1, ovl.fmt.RXY.x2, @@ -15714,6 +17336,11 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe30000000038ULL: /* AGH */ goto unimplemented; + case 0xe30000000039ULL: /* SGH */ goto unimplemented; + case 0xe3000000003aULL: /* LLZRGF */ goto unimplemented; + case 0xe3000000003bULL: /* LZRF */ goto unimplemented; + case 0xe3000000003cULL: /* MGH */ goto unimplemented; case 0xe3000000003eULL: s390_format_RXY_RRRD(s390_irgen_STRV, ovl.fmt.RXY.r1, ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, @@ -15726,6 +17353,11 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe30000000047ULL: /* BIC */ goto unimplemented; + case 0xe30000000048ULL: /* LLGFSG */ goto unimplemented; + case 0xe30000000049ULL: /* STGSC */ goto unimplemented; + case 0xe3000000004cULL: /* LGG */ goto unimplemented; + case 0xe3000000004dULL: /* LGSC */ goto unimplemented; case 0xe30000000050ULL: s390_format_RXY_RRRD(s390_irgen_STY, ovl.fmt.RXY.r1, ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, @@ -15734,6 +17366,7 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe30000000053ULL: /* MSC */ goto unimplemented; case 0xe30000000054ULL: s390_format_RXY_RRRD(s390_irgen_NY, ovl.fmt.RXY.r1, ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, @@ -15838,6 +17471,8 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe30000000083ULL: /* MSGC */ goto unimplemented; + case 0xe30000000084ULL: /* MG */ goto unimplemented; case 0xe30000000085ULL: /* LGAT */ goto unimplemented; case 0xe30000000086ULL: s390_format_RXY_RRRD(s390_irgen_MLG, ovl.fmt.RXY.r1, ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, @@ -15939,6 +17574,290 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RXY.x2, ovl.fmt.RXY.b2, ovl.fmt.RXY.dl2, ovl.fmt.RXY.dh2); goto ok; + case 0xe60000000034ULL: /* VPKZ */ goto unimplemented; + case 0xe60000000035ULL: /* VLRL */ goto unimplemented; + case 0xe60000000037ULL: /* VLRLR */ goto unimplemented; + case 0xe6000000003cULL: /* VUPKZ */ goto unimplemented; + case 0xe6000000003dULL: /* VSTRL */ goto unimplemented; + case 0xe6000000003fULL: /* VSTRLR */ goto unimplemented; + case 0xe60000000049ULL: /* VLIP */ goto unimplemented; + case 0xe60000000050ULL: /* VCVB */ goto unimplemented; + case 0xe60000000052ULL: /* VCVBG */ goto unimplemented; + case 0xe60000000058ULL: /* VCVD */ goto unimplemented; + case 0xe60000000059ULL: /* VSRP */ goto unimplemented; + case 0xe6000000005aULL: /* VCVDG */ goto unimplemented; + case 0xe6000000005bULL: /* VPSOP */ goto unimplemented; + case 0xe6000000005fULL: /* VTP */ goto unimplemented; + case 0xe60000000071ULL: /* VAP */ goto unimplemented; + case 0xe60000000073ULL: /* VSP */ goto unimplemented; + case 0xe60000000077ULL: /* VCP */ goto unimplemented; + case 0xe60000000078ULL: /* VMP */ goto unimplemented; + case 0xe60000000079ULL: /* VMSP */ goto unimplemented; + case 0xe6000000007aULL: /* VDP */ goto unimplemented; + case 0xe6000000007bULL: /* VRP */ goto unimplemented; + case 0xe6000000007eULL: /* VSDP */ goto unimplemented; + case 0xe70000000000ULL: s390_format_VRX_VRRDM(s390_irgen_VLEB, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000001ULL: s390_format_VRX_VRRDM(s390_irgen_VLEH, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000002ULL: s390_format_VRX_VRRDM(s390_irgen_VLEG, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000003ULL: s390_format_VRX_VRRDM(s390_irgen_VLEF, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000004ULL: s390_format_VRX_VRRDM(s390_irgen_VLLEZ, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000005ULL: s390_format_VRX_VRRDM(s390_irgen_VLREP, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000006ULL: s390_format_VRX_VRRD(s390_irgen_VL, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000007ULL: s390_format_VRX_VRRDM(s390_irgen_VLBB, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000008ULL: s390_format_VRX_VRRDM(s390_irgen_VSTEB, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000009ULL: s390_format_VRX_VRRDM(s390_irgen_VSTEH, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe7000000000aULL: s390_format_VRX_VRRDM(s390_irgen_VSTEG, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe7000000000bULL: s390_format_VRX_VRRDM(s390_irgen_VSTEF, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb); goto ok; + case 0xe7000000000eULL: s390_format_VRX_VRRD(s390_irgen_VST, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.rxb); goto ok; + case 0xe70000000012ULL: s390_format_VRV_VVRDMT(s390_irgen_VGEG, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb, Ity_I64); goto ok; + case 0xe70000000013ULL: s390_format_VRV_VVRDMT(s390_irgen_VGEF, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb, Ity_I32); goto ok; + case 0xe7000000001aULL: s390_format_VRV_VVRDMT(s390_irgen_VSCEG, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb, Ity_I64); goto ok; + case 0xe7000000001bULL: s390_format_VRV_VVRDMT(s390_irgen_VSCEF, ovl.fmt.VRX.v1, + ovl.fmt.VRX.x2, ovl.fmt.VRX.b2, + ovl.fmt.VRX.d2, ovl.fmt.VRX.m3, + ovl.fmt.VRX.rxb, Ity_I32); goto ok; + case 0xe70000000021ULL: s390_format_VRS_RRDVM(s390_irgen_VLGV, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.m4, ovl.fmt.VRS.rxb); goto ok; + case 0xe70000000027ULL: /* LCBB */ goto unimplemented; + case 0xe70000000022ULL: s390_format_VRS_VRRDM(s390_irgen_VLVG, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.m4, ovl.fmt.VRS.rxb); goto ok; + case 0xe70000000030ULL: /* VESL */ goto unimplemented; + case 0xe70000000033ULL: /* VERLL */ goto unimplemented; + case 0xe70000000036ULL: s390_format_VRS_VRDV(s390_irgen_VLM, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.rxb); goto ok; + case 0xe70000000037ULL: s390_format_VRS_VRRD(s390_irgen_VLL, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.rxb); goto ok; + case 0xe70000000038ULL: /* VESRL */ goto unimplemented; + case 0xe7000000003aULL: /* VESRA */ goto unimplemented; + case 0xe7000000003eULL: s390_format_VRS_VRDV(s390_irgen_VSTM, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.rxb); goto ok; + case 0xe7000000003fULL: s390_format_VRS_VRRD(s390_irgen_VSTL, ovl.fmt.VRS.v1, + ovl.fmt.VRS.b2, ovl.fmt.VRS.d2, ovl.fmt.VRS.v3, + ovl.fmt.VRS.rxb); goto ok; + case 0xe70000000040ULL: s390_format_VRI_VIM(s390_irgen_VLEIB, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000041ULL: s390_format_VRI_VIM(s390_irgen_VLEIH, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000042ULL: s390_format_VRI_VIM(s390_irgen_VLEIG, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000043ULL: s390_format_VRI_VIM(s390_irgen_VLEIF, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok;break; + case 0xe70000000044ULL: s390_format_VRI_VIM(s390_irgen_VGBM, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000045ULL: s390_format_VRI_VIM(s390_irgen_VREPI, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000046ULL: s390_format_VRI_VIM(s390_irgen_VGM, ovl.fmt.VRI.v1, + ovl.fmt.VRI.i2, ovl.fmt.VRI.m3, + ovl.fmt.VRI.rxb); goto ok; + case 0xe7000000004aULL: /* VFTCI */ goto unimplemented; + case 0xe7000000004dULL: s390_format_VRI_VVIM(s390_irgen_VREP, ovl.fmt.VRI.v1, + ovl.fmt.VRI.v3, ovl.fmt.VRI.i2, + ovl.fmt.VRI.m3, ovl.fmt.VRI.rxb); goto ok; + case 0xe70000000050ULL: /* VPOPCT */ goto unimplemented; + case 0xe70000000052ULL: /* VCTZ */ goto unimplemented; + case 0xe70000000053ULL: /* VCLZ */ goto unimplemented; + case 0xe70000000056ULL: s390_format_VRR_VV(s390_irgen_VLR, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000005cULL: /* VISTR */ goto unimplemented; + case 0xe7000000005fULL: s390_format_VRR_VVM(s390_irgen_VSEG, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.m4, + ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000060ULL: s390_format_VRR_VVVM(s390_irgen_VMRL, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000061ULL: s390_format_VRR_VVVM(s390_irgen_VMRH, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000062ULL: s390_format_VRR_VRR(s390_irgen_VLVGP, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000064ULL: /* VSUM */ goto unimplemented; + case 0xe70000000065ULL: /* VSUMG */ goto unimplemented; + case 0xe70000000066ULL: /* VCKSM */ goto unimplemented; + case 0xe70000000067ULL: /* VSUMQ */ goto unimplemented; + case 0xe70000000068ULL: s390_format_VRR_VVV(s390_irgen_VN, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000069ULL: /* VNC */ goto unimplemented; + case 0xe7000000006aULL: s390_format_VRR_VVV(s390_irgen_VO, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000006bULL: s390_format_VRR_VVV(s390_irgen_VNO, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000006cULL: /* VNX */ goto unimplemented; + case 0xe7000000006dULL: s390_format_VRR_VVV(s390_irgen_VX, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000006eULL: /* VNN */ goto unimplemented; + case 0xe7000000006fULL: /* VOC */ goto unimplemented; + case 0xe70000000070ULL: /* VESLV */ goto unimplemented; + case 0xe70000000072ULL: /* VERIM */ goto unimplemented; + case 0xe70000000073ULL: /* VERLLV */ goto unimplemented; + case 0xe70000000074ULL: /* VSL */ goto unimplemented; + case 0xe70000000075ULL: /* VSLB */ goto unimplemented; + case 0xe70000000077ULL: /* VSLDB */ goto unimplemented; + case 0xe70000000078ULL: /* VESRLV */ goto unimplemented; + case 0xe7000000007aULL: /* VESRAV */ goto unimplemented; + case 0xe7000000007cULL: /* VSRL */ goto unimplemented; + case 0xe7000000007dULL: /* VSRLB */ goto unimplemented; + case 0xe7000000007eULL: /* VSRA */ goto unimplemented; + case 0xe7000000007fULL: /* VSRAB */ goto unimplemented; + case 0xe70000000080ULL: /* VFEE */ goto unimplemented; + case 0xe70000000081ULL: /* VFENE */ goto unimplemented; + case 0xe70000000082ULL: /* VFAE */ goto unimplemented; + case 0xe70000000084ULL: s390_format_VRR_VVVM(s390_irgen_VPDI, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000085ULL: /* VBPERM */ goto unimplemented; + case 0xe7000000008aULL: /* VSTRC */ goto unimplemented; + case 0xe7000000008cULL: s390_format_VRR_VVVV(s390_irgen_VPERM, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000008dULL: s390_format_VRR_VVVV(s390_irgen_VSEL, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000008eULL: /* VFMS */ goto unimplemented; + case 0xe7000000008fULL: /* VFMA */ goto unimplemented; + case 0xe70000000094ULL: s390_format_VRR_VVVM(s390_irgen_VPK, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000095ULL: s390_format_VRR_VVVMM(s390_irgen_VPKLS, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.m5, ovl.fmt.VRR.rxb); goto ok; + case 0xe70000000097ULL: s390_format_VRR_VVVMM(s390_irgen_VPKS, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.r3, + ovl.fmt.VRR.m4, ovl.fmt.VRR.m5, ovl.fmt.VRR.rxb); goto ok; + case 0xe7000000009eULL: /* VFNMS */ goto unimplemented; + case 0xe7000000009fULL: /* VFNMA */ goto unimplemented; + case 0xe700000000a1ULL: /* VMLH */ goto unimplemented; + case 0xe700000000a2ULL: /* VML */ goto unimplemented; + case 0xe700000000a3ULL: /* VMH */ goto unimplemented; + case 0xe700000000a4ULL: /* VMLE */ goto unimplemented; + case 0xe700000000a5ULL: /* VMLO */ goto unimplemented; + case 0xe700000000a6ULL: /* VME */ goto unimplemented; + case 0xe700000000a7ULL: /* VMO */ goto unimplemented; + case 0xe700000000a9ULL: /* VMALH */ goto unimplemented; + case 0xe700000000aaULL: /* VMAL */ goto unimplemented; + case 0xe700000000abULL: /* VMAH */ goto unimplemented; + case 0xe700000000acULL: /* VMALE */ goto unimplemented; + case 0xe700000000adULL: /* VMALO */ goto unimplemented; + case 0xe700000000aeULL: /* VMAE */ goto unimplemented; + case 0xe700000000afULL: /* VMAO */ goto unimplemented; + case 0xe700000000b4ULL: /* VGFM */ goto unimplemented; + case 0xe700000000b8ULL: /* VMSL */ goto unimplemented; + case 0xe700000000b9ULL: /* VACCC */ goto unimplemented; + case 0xe700000000bbULL: /* VAC */ goto unimplemented; + case 0xe700000000bcULL: /* VGFMA */ goto unimplemented; + case 0xe700000000bdULL: /* VSBCBI */ goto unimplemented; + case 0xe700000000bfULL: /* VSBI */ goto unimplemented; + case 0xe700000000c0ULL: /* VCLGD */ goto unimplemented; + case 0xe700000000c1ULL: /* VCDLG */ goto unimplemented; + case 0xe700000000c2ULL: /* VCGD */ goto unimplemented; + case 0xe700000000c3ULL: /* VCDG */ goto unimplemented; + case 0xe700000000c4ULL: /* VLDE */ goto unimplemented; + case 0xe700000000c5ULL: /* VLED */ goto unimplemented; + case 0xe700000000c7ULL: /* VFI */ goto unimplemented; + case 0xe700000000caULL: /* WFK */ goto unimplemented; + case 0xe700000000cbULL: /* WFC */ goto unimplemented; + case 0xe700000000ccULL: /* VFPSO */ goto unimplemented; + case 0xe700000000ceULL: /* VFSQ */ goto unimplemented; + case 0xe700000000d4ULL: s390_format_VRR_VVM(s390_irgen_VUPLL, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.m4, + ovl.fmt.VRR.rxb); goto ok; + case 0xe700000000d5ULL: s390_format_VRR_VVM(s390_irgen_VUPLH, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.m4, + ovl.fmt.VRR.rxb); goto ok; + case 0xe700000000d6ULL: s390_format_VRR_VVM(s390_irgen_VUPL, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.m4, + ovl.fmt.VRR.rxb); goto ok; + case 0xe700000000d7ULL: s390_format_VRR_VVM(s390_irgen_VUPH, ovl.fmt.VRR.v1, + ovl.fmt.VRR.v2, ovl.fmt.VRR.m4, + ovl.fmt.VRR.rxb); goto ok; + case 0xe700000000d8ULL: /* VTM */ goto unimplemented; + case 0xe700000000d9ULL: /* VECL */ goto unimplemented; + case 0xe700000000dbULL: /* VEC */ goto unimplemented; + case 0xe700000000deULL: /* VLC */ goto unimplemented; + case 0xe700000000dfULL: /* VLP */ goto unimplemented; + case 0xe700000000e2ULL: /* VFS */ goto unimplemented; + case 0xe700000000e3ULL: /* VFA */ goto unimplemented; + case 0xe700000000e5ULL: /* VFD */ goto unimplemented; + case 0xe700000000e7ULL: /* VFM */ goto unimplemented; + case 0xe700000000e8ULL: /* VFCE */ goto unimplemented; + case 0xe700000000eaULL: /* VFCHE */ goto unimplemented; + case 0xe700000000ebULL: /* VFCH */ goto unimplemented; + case 0xe700000000eeULL: /* VFMIN */ goto unimplemented; + case 0xe700000000efULL: /* VFMAX */ goto unimplemented; + case 0xe700000000f0ULL: /* VAVGL */ goto unimplemented; + case 0xe700000000f1ULL: /* VACC */ goto unimplemented; + case 0xe700000000f2ULL: /* VAVG */ goto unimplemented; + case 0xe700000000f3ULL: /* VA */ goto unimplemented; + case 0xe700000000f5ULL: /* VSCBI */ goto unimplemented; + case 0xe700000000f7ULL: /* VS */ goto unimplemented; + case 0xe700000000f8ULL: /* VCEQ */ goto unimplemented; + case 0xe700000000f9ULL: /* VCHL */ goto unimplemented; + case 0xe700000000fbULL: /* VCH */ goto unimplemented; + case 0xe700000000fcULL: /* VMNL */ goto unimplemented; + case 0xe700000000fdULL: /* VMXL */ goto unimplemented; + case 0xe700000000feULL: /* VMN */ goto unimplemented; + case 0xe700000000ffULL: /* VMX */ goto unimplemented; case 0xeb0000000004ULL: s390_format_RSY_RRRD(s390_irgen_LMG, ovl.fmt.RSY.r1, ovl.fmt.RSY.r3, ovl.fmt.RSY.b2, ovl.fmt.RSY.dl2, @@ -16101,6 +18020,8 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RSY.r3, ovl.fmt.RSY.b2, ovl.fmt.RSY.dl2, ovl.fmt.RSY.dh2); goto ok; + case 0xeb00000000e0ULL: /* LOCFH */ goto unimplemented; + case 0xeb00000000e1ULL: /* STOCFH */ goto unimplemented; case 0xeb00000000e2ULL: s390_format_RSY_RDRM(s390_irgen_LOCG, ovl.fmt.RSY.r1, ovl.fmt.RSY.r3, ovl.fmt.RSY.b2, ovl.fmt.RSY.dl2, @@ -16161,12 +18082,15 @@ s390_decode_6byte_and_irgen(const UChar *bytes) ovl.fmt.RSY.r3, ovl.fmt.RSY.b2, ovl.fmt.RSY.dl2, ovl.fmt.RSY.dh2); goto ok; + case 0xec0000000042ULL: /* LOCHI */ goto unimplemented; case 0xec0000000044ULL: s390_format_RIE_RRP(s390_irgen_BRXHG, ovl.fmt.RIE.r1, ovl.fmt.RIE.r3, ovl.fmt.RIE.i2); goto ok; case 0xec0000000045ULL: s390_format_RIE_RRP(s390_irgen_BRXLG, ovl.fmt.RIE.r1, ovl.fmt.RIE.r3, ovl.fmt.RIE.i2); goto ok; + case 0xec0000000046ULL: /* LOCGHI */ goto unimplemented; + case 0xec000000004eULL: /* LOCHHI */ goto unimplemented; case 0xec0000000051ULL: s390_format_RIE_RRUUU(s390_irgen_RISBLG, ovl.fmt.RIE_RRUUU.r1, ovl.fmt.RIE_RRUUU.r2, @@ -16451,6 +18375,10 @@ s390_decode_6byte_and_irgen(const UChar *bytes) case 0xed00000000a9ULL: /* CZXT */ goto unimplemented; case 0xed00000000aaULL: /* CDZT */ goto unimplemented; case 0xed00000000abULL: /* CXZT */ goto unimplemented; + case 0xed00000000acULL: /* CPDT */ goto unimplemented; + case 0xed00000000adULL: /* CPXT */ goto unimplemented; + case 0xed00000000aeULL: /* CDPT */ goto unimplemented; + case 0xed00000000afULL: /* CXPT */ goto unimplemented; } switch (((ovl.value >> 16) & 0xff0f00000000ULL) >> 32) { diff --git a/VEX/priv/host_s390_defs.c b/VEX/priv/host_s390_defs.c index f9a9557617..d03ed5f07c 100644 --- a/VEX/priv/host_s390_defs.c +++ b/VEX/priv/host_s390_defs.c @@ -60,6 +60,7 @@ static UInt s390_tchain_load64_len(void); /* A mapping from register number to register index */ static Int gpr_index[16]; // GPR regno -> register index static Int fpr_index[16]; // FPR regno -> register index +static Int vr_index[32]; // VR regno -> register index HReg s390_hreg_gpr(UInt regno) @@ -77,6 +78,14 @@ s390_hreg_fpr(UInt regno) return mkHReg(/*virtual*/False, HRcFlt64, regno, ix); } +HReg +s390_hreg_vr(UInt regno) +{ + Int ix = vr_index[regno]; + vassert(ix >= 0); + return mkHReg(/*virtual*/False, HRcVec128, regno, ix); +} + static __inline__ UInt hregNumber(HReg reg) { @@ -99,6 +108,13 @@ s390_hreg_as_string(HReg reg) "%f8", "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15" }; + static const HChar vreg_names[32][5] = { + "%v0", "%v1", "%v2", "%v3", "%v4", "%v5", "%v6", "%v7", + "%v8", "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15", + "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23", + "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31" + }; + UInt r; /* hregNumber() returns an UInt */ r = hregNumber(reg); @@ -109,18 +125,18 @@ s390_hreg_as_string(HReg reg) switch (hregClass(reg)) { case HRcInt64: vex_sprintf(buf, "%%vR%u", r); break; case HRcFlt64: vex_sprintf(buf, "%%vF%u", r); break; + case HRcVec128: vex_sprintf(buf, "%%vV%u", r); break; default: goto fail; } return buf; } /* But specific for real regs. */ - vassert(r < 16); - switch (hregClass(reg)) { - case HRcInt64: return ireg_names[r]; - case HRcFlt64: return freg_names[r]; - default: goto fail; + case HRcInt64: vassert(r < 16); return ireg_names[r]; + case HRcFlt64: vassert(r < 16); return freg_names[r]; + case HRcVec128: vassert(r < 32); return vreg_names[r]; + default: goto fail; } fail: vpanic("s390_hreg_as_string"); @@ -134,6 +150,13 @@ s390_hreg_guest_state_pointer(void) return s390_hreg_gpr(S390_REGNO_GUEST_STATE_POINTER); } +/* Return the real register that holds the stack pointer */ +HReg +s390_hreg_stack_pointer(void) +{ + return s390_hreg_gpr(S390_REGNO_STACK_POINTER); +} + /* Is VALUE within the domain of a 20-bit signed integer. */ static __inline__ Bool @@ -245,6 +268,24 @@ s390_amode_for_guest_state(Int offset) } +/* Construct an AMODE for accessing stack pointer at OFFSET. + OFFSET can be at most 3 * sizeof(VexGuestS390XState) + LibVEX_N_SPILL_BYTES + which may be too large for a B12 addressing mode. + Use a B20 amode as a fallback which will be safe for any offset. +*/ +s390_amode * +s390_amode_for_stack_pointer(Int offset) +{ + if (fits_unsigned_12bit(offset)) + return s390_amode_b12(offset, s390_hreg_stack_pointer()); + + if (fits_signed_20bit(offset)) + return s390_amode_b20(offset, s390_hreg_stack_pointer()); + + vpanic("invalid stack pointer offset"); +} + + /* Decompile the given amode into a static buffer and return it. */ const HChar * s390_amode_as_string(const s390_amode *am) @@ -284,6 +325,39 @@ is_virtual_gpr(HReg reg) return hregIsVirtual(reg) && hregClass(reg) == HRcInt64; } +/* Helper function for all vector operations */ +static UChar +s390_getM_from_size(const UChar size) { + switch(size) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + case 16: + return 4; + default: + vex_printf("size=%d\n", size); + vpanic("s390_getM_from_size: unknown size"); + } +} + +/* Helper for generating RXB field in vector instructions */ +static UChar +s390_update_rxb(const UChar rxb, const UChar index, UChar* vr) { + vassert((index >= 1) && (index <= 4)); + UChar result = rxb; + if(vr != NULL) { + if(*vr >= 16) { + result |= 1 << (4 - index); + *vr -= 16; + } + } + return result; +} /* Sanity check for an amode */ Bool @@ -389,11 +463,14 @@ getRRegUniverse_S390(void) RRegUniverse__init(ru); - /* Assign invalid values to the gpr/fpr_index */ + /* Assign invalid values to the gpr/fpr/vr_index */ for (UInt i = 0; i < sizeof gpr_index / sizeof gpr_index[0]; ++i) gpr_index[i] = -1; for (UInt i = 0; i < sizeof fpr_index / sizeof fpr_index[0]; ++i) fpr_index[i] = -1; + for (UInt i = 0; i < sizeof vr_index / sizeof vr_index[0]; ++i) + vr_index[i] = -1; + /* Add the registers that are available to the register allocator. GPRs: registers 6..11 are callee saved, list them first @@ -402,6 +479,7 @@ getRRegUniverse_S390(void) registers 0..7 are caller saved, list them after FPR12 - FPR15 are also used as register pairs for 128-bit floating point operations + VRs: registers 0..31 are available */ ru->allocable_start[HRcInt64] = ru->size; for (UInt regno = 6; regno <= 11; ++regno) { @@ -424,6 +502,13 @@ getRRegUniverse_S390(void) ru->regs[ru->size++] = s390_hreg_fpr(regno); } ru->allocable_end[HRcFlt64] = ru->size - 1; + + ru->allocable_start[HRcVec128] = ru->size; + for (UInt regno = 0; regno <= 31; ++regno) { + vr_index[regno] = ru->size; + ru->regs[ru->size++] = s390_hreg_vr(regno); + } + ru->allocable_end[HRcVec128] = ru->size - 1; ru->allocable = ru->size; /* Add the registers that are not available for allocation. @@ -444,6 +529,8 @@ getRRegUniverse_S390(void) vassert(gpr_index[i] >= 0); for (UInt i = 0; i < sizeof fpr_index / sizeof fpr_index[0]; ++i) vassert(fpr_index[i] >= 0); + for (UInt i = 0; i < sizeof vr_index / sizeof vr_index[0]; ++i) + vassert(vr_index[i] >= 0); initialised = True; return ru; @@ -486,7 +573,9 @@ genSpill_S390(HInstr **i1, HInstr **i2, HReg rreg, Int offsetB, Bool mode64) case HRcFlt64: *i1 = s390_insn_store(8, am, rreg); return; - + case HRcVec128: + *i1 = s390_insn_store(16, am, rreg); + return; default: ppHRegClass(hregClass(rreg)); vpanic("genSpill_S390: unimplemented regclass"); @@ -512,7 +601,9 @@ genReload_S390(HInstr **i1, HInstr **i2, HReg rreg, Int offsetB, Bool mode64) case HRcFlt64: *i1 = s390_insn_load(8, rreg, am); return; - + case HRcVec128: + *i1 = s390_insn_load(16, rreg, am); + return; default: ppHRegClass(hregClass(rreg)); vpanic("genReload_S390: unimplemented regclass"); @@ -524,6 +615,8 @@ s390_insn* genMove_S390(HReg from, HReg to, Bool mode64) switch (hregClass(from)) { case HRcInt64: return s390_insn_move(sizeofIRType(Ity_I64), to, from); + case HRcVec128: + return s390_insn_move(sizeofIRType(Ity_V128), to, from); default: ppHRegClass(hregClass(from)); vpanic("genMove_S390: unimplemented regclass"); @@ -859,6 +952,32 @@ s390_insn_get_reg_usage(HRegUsage *u, const s390_insn *insn) s390_amode_get_reg_usage(u, insn->variant.xassisted.guest_IA); break; + case S390_INSN_VEC_AMODEOP: + addHRegUse(u, HRmWrite, insn->variant.vec_amodeop.dst); + addHRegUse(u, HRmRead, insn->variant.vec_amodeop.op1); + s390_amode_get_reg_usage(u, insn->variant.vec_amodeop.op2); + break; + + case S390_INSN_VEC_AMODEINTOP: + addHRegUse(u, HRmRead, insn->variant.vec_amodeintop.dst); + addHRegUse(u, HRmWrite, insn->variant.vec_amodeintop.dst); + s390_amode_get_reg_usage(u, insn->variant.vec_amodeintop.op2); + addHRegUse(u, HRmRead, insn->variant.vec_amodeintop.op3); + break; + + case S390_INSN_VEC_BINOP: + addHRegUse(u, HRmWrite, insn->variant.vec_binop.dst); + addHRegUse(u, HRmRead, insn->variant.vec_binop.op1); + addHRegUse(u, HRmRead, insn->variant.vec_binop.op2); + break; + + case S390_INSN_VEC_TRIOP: + addHRegUse(u, HRmWrite, insn->variant.vec_triop.dst); + addHRegUse(u, HRmRead, insn->variant.vec_triop.op1); + addHRegUse(u, HRmRead, insn->variant.vec_triop.op2); + addHRegUse(u, HRmRead, insn->variant.vec_triop.op3); + break; + default: vpanic("s390_insn_get_reg_usage"); } @@ -1207,6 +1326,41 @@ s390_insn_map_regs(HRegRemap *m, s390_insn *insn) lookupHRegRemap(m, insn->variant.xassisted.dst); break; + case S390_INSN_VEC_AMODEOP: + insn->variant.vec_amodeop.dst = + lookupHRegRemap(m, insn->variant.vec_amodeop.dst); + insn->variant.vec_amodeop.op1 = + lookupHRegRemap(m, insn->variant.vec_amodeop.op1); + s390_amode_map_regs(m, insn->variant.vec_amodeop.op2); + break; + + case S390_INSN_VEC_AMODEINTOP: + insn->variant.vec_amodeintop.dst = + lookupHRegRemap(m, insn->variant.vec_amodeintop.dst); + s390_amode_map_regs(m, insn->variant.vec_amodeintop.op2); + insn->variant.vec_amodeintop.op3 = + lookupHRegRemap(m, insn->variant.vec_amodeintop.op3); + break; + + case S390_INSN_VEC_BINOP: + insn->variant.vec_binop.dst = + lookupHRegRemap(m, insn->variant.vec_binop.dst); + insn->variant.vec_binop.op1 = + lookupHRegRemap(m, insn->variant.vec_binop.op1); + insn->variant.vec_binop.op2 = + lookupHRegRemap(m, insn->variant.vec_binop.op2); + break; + + case S390_INSN_VEC_TRIOP: + insn->variant.vec_triop.dst = + lookupHRegRemap(m, insn->variant.vec_triop.dst); + insn->variant.vec_triop.op1 = + lookupHRegRemap(m, insn->variant.vec_triop.op1); + insn->variant.vec_triop.op2 = + lookupHRegRemap(m, insn->variant.vec_triop.op2); + insn->variant.vec_triop.op3 = + lookupHRegRemap(m, insn->variant.vec_triop.op3); + break; default: vpanic("s390_insn_map_regs"); } @@ -1497,6 +1651,121 @@ emit_SSa(UChar *p, ULong op, UChar l, UChar b1, UShort d1, UChar b2, UShort d2) } +static UChar * +emit_VRI_VI(UChar *p, ULong op, UChar v1, UShort i2) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, &v1); + + the_insn |= ((ULong)v1) << 36; + the_insn |= ((ULong)i2) << 16; + the_insn |= ((ULong)rxb)<< 8; + + return emit_6bytes(p, the_insn); +} + + +static UChar * +emit_VRX(UChar *p, ULong op, UChar v1, UChar x2, UChar b2, UShort d2) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, &v1); + + the_insn |= ((ULong)v1) << 36; + the_insn |= ((ULong)x2) << 32; + the_insn |= ((ULong)b2) << 28; + the_insn |= ((ULong)d2) << 16; + the_insn |= ((ULong)rxb)<< 8; + + return emit_6bytes(p, the_insn); +} + + +static UChar * +emit_VRS(UChar *p, ULong op, UChar reg1, UChar b2, UShort d2, UChar reg3, UChar m4) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, ®1); + rxb = s390_update_rxb(rxb, 2, ®3); + + the_insn |= ((ULong)reg1) << 36; + the_insn |= ((ULong)reg3) << 32; + the_insn |= ((ULong)b2) << 28; + the_insn |= ((ULong)d2) << 16; + the_insn |= ((ULong)m4) << 12; + the_insn |= ((ULong)rxb) << 8; + + return emit_6bytes(p, the_insn); +} + + +static UChar * +emit_VRR_VVM(UChar *p, ULong op, UChar v1, UChar v2, UChar m4) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, &v1); + rxb = s390_update_rxb(rxb, 2, &v2); + + the_insn |= ((ULong)v1) << 36; + the_insn |= ((ULong)v2) << 32; + the_insn |= ((ULong)m4) << 12; + the_insn |= ((ULong)rxb)<< 8; + + return emit_6bytes(p, the_insn); +} + + +static UChar * +emit_VRR_VVVM(UChar *p, ULong op, UChar v1, UChar v2, UChar v3, UChar m4) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, &v1); + rxb = s390_update_rxb(rxb, 2, &v2); + rxb = s390_update_rxb(rxb, 3, &v3); + + the_insn |= ((ULong)v1) << 36; + the_insn |= ((ULong)v2) << 32; + the_insn |= ((ULong)v3) << 28; + the_insn |= ((ULong)m4) << 12; + the_insn |= ((ULong)rxb)<< 8; + + return emit_6bytes(p, the_insn); +} + + +static UChar * +emit_VRR_VVV(UChar *p, ULong op, UChar v1, UChar v2, UChar v3) +{ + return emit_VRR_VVVM(p, op, v1, v2, v3, 0); +} + + +static UChar * +emit_VRR_VV(UChar *p, ULong op, UChar v1, UChar v2) +{ + return emit_VRR_VVM(p, op, v1, v2, 0); +} + + +static UChar * +emit_VRR_VVVV(UChar *p, ULong op, UChar v1, UChar v2, UChar v3, UChar v4) +{ + ULong the_insn = op; + ULong rxb = s390_update_rxb(0, 1, &v1); + rxb = s390_update_rxb(rxb, 2, &v2); + rxb = s390_update_rxb(rxb, 3, &v3); + rxb = s390_update_rxb(rxb, 4, &v4); + + the_insn |= ((ULong)v1) << 36; + the_insn |= ((ULong)v2) << 32; + the_insn |= ((ULong)v3) << 28; + the_insn |= ((ULong)v4) << 12; + the_insn |= ((ULong)rxb)<< 8; + + return emit_6bytes(p, the_insn); +} + + /*------------------------------------------------------------*/ /*--- Functions to emit particular instructions ---*/ /*------------------------------------------------------------*/ @@ -5259,6 +5528,192 @@ s390_emit_LDGRw(UChar *p, UChar r1, UChar r2) } +static UChar * +s390_emit_VL(UChar *p, UChar v1, UChar x2, UChar b2, UShort d2) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC3(MNM, VR, UDXB), "vl", v1, d2, x2, b2); + + return emit_VRX(p, 0xE70000000006ULL, v1, x2, b2, d2); +} + +static UChar * +s390_emit_VLR(UChar *p, UChar v1, UChar v2) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC3(MNM, VR, UDXB), "vlr", v1, v2); + + return emit_VRR_VV(p, 0xE70000000056ULL, v1, v2); +} + + +static UChar * +s390_emit_VST(UChar *p, UChar v1, UChar x2, UChar b2, UShort d2) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC3(MNM, VR, UDXB), "vst", v1, d2, x2, b2); + + return emit_VRX(p, 0xE7000000000eULL, v1, x2, b2, d2); +} + + +static UChar * +s390_emit_VLGV(UChar *p, UChar r1, UChar b2, UShort d2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, GPR, UDXB, VR, UINT), "vlgv", r1, d2, 0, b2, v3, m4); + + return emit_VRS(p, 0xE70000000021ULL, r1, b2, d2, v3, m4); +} + + +static UChar * +s390_emit_VLVG(UChar *p, UChar v1, UChar b2, UShort d2, UChar r3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, UDXB, GPR, UINT), "vlvg", v1, d2, 0, b2, r3, m4); + + return emit_VRS(p, 0xE70000000022ULL, v1, b2, d2, r3, m4); +} + + +static UChar * +s390_emit_VPERM(UChar *p, UChar v1, UChar v2, UChar v3, UChar v4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, VR, VR), "vperm", v1, v2, v3, v4); + + return emit_VRR_VVVV(p, 0xE7000000008cULL, v1, v2, v3, v4); +} + +static UChar * +s390_emit_VO(UChar *p, UChar v1, UChar v2, UChar v3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC4(MNM, VR, VR, VR), "vo", v1, v2, v3); + + return emit_VRR_VVV(p, 0xE7000000006aULL, v1, v2, v3); +} + +static UChar * +s390_emit_VX(UChar *p, UChar v1, UChar v2, UChar v3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC4(MNM, VR, VR, VR), "vx", v1, v2, v3); + + return emit_VRR_VVV(p, 0xE7000000006dULL, v1, v2, v3); +} + +static UChar * +s390_emit_VN(UChar *p, UChar v1, UChar v2, UChar v3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC4(MNM, VR, VR, VR), "vn", v1, v2, v3); + + return emit_VRR_VVV(p, 0xE70000000068ULL, v1, v2, v3); +} + +static UChar* +s390_emit_VCEQ(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, VR, UINT), "vceq", v1, v2, v3, m4); + + return emit_VRR_VVVM(p, 0xE700000000f8ULL, v1, v2, v3, m4); +} + + +static UChar * +s390_emit_VGBM(UChar *p, UChar v1, UShort i2) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC3(MNM, VR, UINT), "vgbm", v1, i2); + + return emit_VRI_VI(p, 0xE70000000044ULL, v1, i2); +} + + +static UChar * +s390_emit_VPK(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, VR, UINT), "vpk", v1, v2, v3, m4); + + return emit_VRR_VVVM(p, 0xE70000000094ULL, v1, v2, v3, m4); +} + + +static UChar * +s390_emit_VPKS(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC6(MNM, VR, VR, VR, UINT, UINT), "vpks", v1, v2, v3, m4, 0); + + return emit_VRR_VVVM(p, 0xE70000000097ULL, v1, v2, v3, m4); +} + + +static UChar * +s390_emit_VPKLS(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC6(MNM, VR, VR, VR, UINT, UINT), "vpkls", v1, v2, v3, m4, 0); + + return emit_VRR_VVVM(p, 0xE70000000095ULL, v1, v2, v3, m4); +} + + +static UChar * +s390_emit_VREP(UChar *p, UChar v1, UChar v3, UChar m3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, UINT, UINT), "vrep", v1, v3, 0, m3); + + return emit_VRR_VVM(p, 0xE7000000004DULL, v1, v3, m3); +} + + + +static UChar * +s390_emit_VUPH(UChar *p, UChar v1, UChar v3, UChar m3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC4(MNM, VR, VR, UINT), "vuph", v1, v3, m3); + + return emit_VRR_VVM(p, 0xE700000000D7ULL, v1, v3, m3); +} + + +static UChar * +s390_emit_VUPLH(UChar *p, UChar v1, UChar v3, UChar m3) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC4(MNM, VR, VR, UINT), "vuplh", v1, v3, m3); + + return emit_VRR_VVM(p, 0xE700000000D5ULL, v1, v3, m3); +} + + +static UChar* +s390_emit_VMRH(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, VR, UINT), "vmrh", v1, v2, v3, m4); + + return emit_VRR_VVVM(p, 0xE70000000061ULL, v1, v2, v3, m4); +} + + +static UChar* +s390_emit_VMRL(UChar *p, UChar v1, UChar v2, UChar v3, UChar m4) +{ + if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) + s390_disasm(ENC5(MNM, VR, VR, VR, UINT), "vmrl", v1, v2, v3, m4); + + return emit_VRR_VVVM(p, 0xE70000000060ULL, v1, v2, v3, m4); +} + + /*---------------------------------------------------------------*/ /*--- Constructors for the various s390_insn kinds ---*/ /*---------------------------------------------------------------*/ @@ -5273,7 +5728,7 @@ s390_insn_load(UChar size, HReg dst, s390_amode *src) insn->variant.load.src = src; insn->variant.load.dst = dst; - vassert(size == 1 || size == 2 || size == 4 || size == 8); + vassert(size == 1 || size == 2 || size == 4 || size == 8 || size == 16); return insn; } @@ -5289,7 +5744,7 @@ s390_insn_store(UChar size, s390_amode *dst, HReg src) insn->variant.store.src = src; insn->variant.store.dst = dst; - vassert(size == 1 || size == 2 || size == 4 || size == 8); + vassert(size == 1 || size == 2 || size == 4 || size == 8 || size == 16); return insn; } @@ -5305,7 +5760,7 @@ s390_insn_move(UChar size, HReg dst, HReg src) insn->variant.move.src = src; insn->variant.move.dst = dst; - vassert(size == 1 || size == 2 || size == 4 || size == 8); + vassert(size == 1 || size == 2 || size == 4 || size == 8 || size ==16); return insn; } @@ -6346,6 +6801,76 @@ s390_insn_profinc(void) } +s390_insn * +s390_insn_vec_amodeop(UChar size, s390_vec_amodeop_t tag, HReg dst, HReg op1, + s390_amode *op2) +{ + s390_insn *insn = LibVEX_Alloc_inline(sizeof(s390_insn)); + + vassert(size == 1 || size == 2 || size == 4 || size == 8); + + insn->tag = S390_INSN_VEC_AMODEOP; + insn->size = size; + insn->variant.vec_amodeop.tag = tag; + insn->variant.vec_amodeop.dst = dst; + insn->variant.vec_amodeop.op1 = op1; + insn->variant.vec_amodeop.op2 = op2; + + return insn; +} + +s390_insn *s390_insn_vec_amodeintop(UChar size, s390_vec_amodeintop_t tag, HReg dst, + s390_amode* op2, HReg op3) +{ + s390_insn *insn = LibVEX_Alloc_inline(sizeof(s390_insn)); + + vassert(size == 1 || size == 2 || size == 4 || size == 8); + + insn->tag = S390_INSN_VEC_AMODEINTOP; + insn->size = size; + insn->variant.vec_amodeintop.tag = tag; + insn->variant.vec_amodeintop.dst = dst; + insn->variant.vec_amodeintop.op2 = op2; + insn->variant.vec_amodeintop.op3 = op3; + + return insn; +} + +s390_insn *s390_insn_vec_binop(UChar size, s390_vec_binop_t tag, HReg dst, + HReg op1, HReg op2) +{ + s390_insn *insn = LibVEX_Alloc_inline(sizeof(s390_insn)); + + vassert(size == 1 || size == 2 || size == 4 || size == 8 || size == 16); + + insn->tag = S390_INSN_VEC_BINOP; + insn->size = size; + insn->variant.vec_binop.tag = tag; + insn->variant.vec_binop.dst = dst; + insn->variant.vec_binop.op1 = op1; + insn->variant.vec_binop.op2 = op2; + + return insn; +} + +s390_insn *s390_insn_vec_triop(UChar size, s390_vec_triop_t tag, HReg dst, + HReg op1, HReg op2, HReg op3) +{ + s390_insn *insn = LibVEX_Alloc_inline(sizeof(s390_insn)); + + vassert(size == 16); + + insn->tag = S390_INSN_VEC_TRIOP; + insn->size = size; + insn->variant.vec_triop.tag = tag; + insn->variant.vec_triop.dst = dst; + insn->variant.vec_triop.op1 = op1; + insn->variant.vec_triop.op2 = op2; + insn->variant.vec_triop.op3 = op3; + + return insn; +} + /*---------------------------------------------------------------*/ /*--- Debug print ---*/ /*---------------------------------------------------------------*/ @@ -6623,6 +7148,22 @@ s390_insn_as_string(const s390_insn *insn) op = "v-neg"; break; + case S390_VEC_FILL: + op = "v-vfill"; + break; + + case S390_VEC_DUPLICATE: + op = "v-vdup"; + break; + + case S390_VEC_UNPACKLOWS: + op = "v-vunpacks"; + break; + + case S390_VEC_UNPACKLOWU: + op = "v-vunpacku"; + break; + default: goto fail; } @@ -6931,6 +7472,53 @@ s390_insn_as_string(const s390_insn *insn) insn->variant.xassisted.dst); return buf; /* avoid printing "size = ..." which is meaningless */ + case S390_INSN_VEC_AMODEOP: + switch (insn->variant.vec_amodeop.tag) { + case S390_VEC_GET_ELEM: op = "v-vgetelem"; break; + default: goto fail; + } + s390_sprintf(buf, "%M %R, %R, %A", op, insn->variant.vec_amodeop.dst, + insn->variant.vec_amodeop.op1, + insn->variant.vec_amodeop.op2); + break; + + case S390_INSN_VEC_AMODEINTOP: + switch (insn->variant.vec_amodeintop.tag) { + case S390_VEC_SET_ELEM: op = "v-vsetelem"; break; + default: goto fail; + } + s390_sprintf(buf, "%M %R, %A, %R", op, insn->variant.vec_amodeintop.dst, + insn->variant.vec_amodeintop.op2, + insn->variant.vec_amodeintop.op3); + break; + + case S390_INSN_VEC_BINOP: + switch (insn->variant.vec_binop.tag) { + case S390_VEC_PACK: op = "v-vpack"; break; + case S390_VEC_PACK_SATURS: op = "v-vpacksaturs"; break; + case S390_VEC_PACK_SATURU: op = "v-vpacksaturu"; break; + case S390_VEC_COMPARE_EQUAL: op = "v-vcmpeq"; break; + case S390_VEC_OR: op = "v-vor"; break; + case S390_VEC_XOR: op = "v-vxor"; break; + case S390_VEC_AND: op = "v-vand"; break; + case S390_VEC_MERGEL: op = "v-vmergel"; break; + case S390_VEC_MERGEH: op = "v-vmergeh"; break; + default: goto fail; + } + s390_sprintf(buf, "%M %R, %R, %R", op, insn->variant.vec_binop.dst, + insn->variant.vec_binop.op1, insn->variant.vec_binop.op2); + break; + + case S390_INSN_VEC_TRIOP: + switch (insn->variant.vec_triop.tag) { + case S390_VEC_PERM: op = "v-vperm"; break; + default: goto fail; + } + s390_sprintf(buf, "%M %R, %R, %R, %R", op, insn->variant.vec_triop.dst, + insn->variant.vec_triop.op1, insn->variant.vec_triop.op2, + insn->variant.vec_triop.op3); + break; + default: goto fail; } @@ -7082,10 +7670,11 @@ s390_emit_load_mem(UChar *p, UInt num, UChar reg, const s390_amode *am) case S390_AMODE_B12: case S390_AMODE_BX12: switch (num) { - case 1: return s390_emit_IC(p, reg, x, b, d); - case 2: return s390_emit_LH(p, reg, x, b, d); - case 4: return s390_emit_L(p, reg, x, b, d); - case 8: return s390_emit_LG(p, reg, x, b, DISP20(d)); + case 1: return s390_emit_IC(p, reg, x, b, d); + case 2: return s390_emit_LH(p, reg, x, b, d); + case 4: return s390_emit_L(p, reg, x, b, d); + case 8: return s390_emit_LG(p, reg, x, b, DISP20(d)); + case 16: return s390_emit_VL(p, reg, x, b, d); default: goto fail; } break; @@ -7217,6 +7806,17 @@ s390_insn_store_emit(UChar *buf, const s390_insn *insn) vpanic("s390_insn_store_emit"); } + if (hregClass(insn->variant.store.src) == HRcVec128) { + vassert(insn->size == 16); + switch (dst->tag) { + case S390_AMODE_B12: + case S390_AMODE_BX12: + return s390_emit_VST(buf, r, x, b, d); + + default: + vpanic("s390_insn_store_emit: unknown dst->tag for HRcVec128"); + } + } /* Integer stuff */ switch (insn->size) { case 1: @@ -7300,6 +7900,12 @@ s390_insn_move_emit(UChar *buf, const s390_insn *insn) return s390_emit_LGDRw(buf, dst, src); } } + + if (dst_class == HRcVec128 && src_class == HRcVec128) { + if(insn->size == 16) { + return s390_emit_VLR(buf, dst, src); + } + } /* A move between floating point registers and general purpose registers of different size should never occur and indicates an error elsewhere. */ @@ -8001,6 +8607,32 @@ s390_insn_unop_emit(UChar *buf, const s390_insn *insn) case S390_SIGN_EXTEND_32: return s390_widen_emit(buf, insn, 4, 1); case S390_NEGATE: return s390_negate_emit(buf, insn); + case S390_VEC_FILL: { + vassert(insn->variant.unop.src.tag == S390_OPND_IMMEDIATE); + UChar v1 = hregNumber(insn->variant.unop.dst); + UShort i2 = insn->variant.unop.src.variant.imm; + return s390_emit_VGBM(buf, v1, i2); + } + case S390_VEC_DUPLICATE: { + vassert(insn->variant.unop.src.tag == S390_OPND_REG); + UChar v1 = hregNumber(insn->variant.unop.dst); + UChar v2 = hregNumber(insn->variant.unop.src.variant.reg); + return s390_emit_VREP(buf, v1, v2, s390_getM_from_size(insn->size)); + } + case S390_VEC_UNPACKLOWS: { + vassert(insn->variant.unop.src.tag == S390_OPND_REG); + vassert(insn->size < 8); + UChar v1 = hregNumber(insn->variant.unop.dst); + UChar v2 = hregNumber(insn->variant.unop.src.variant.reg); + return s390_emit_VUPH(buf, v1, v2, s390_getM_from_size(insn->size)); + } + case S390_VEC_UNPACKLOWU: { + vassert(insn->variant.unop.src.tag == S390_OPND_REG); + vassert(insn->size < 8); + UChar v1 = hregNumber(insn->variant.unop.dst); + UChar v2 = hregNumber(insn->variant.unop.src.variant.reg); + return s390_emit_VUPLH(buf, v1, v2, s390_getM_from_size(insn->size)); + } } vpanic("s390_insn_unop_emit"); @@ -9831,6 +10463,112 @@ s390_insn_profinc_emit(UChar *buf, } +static UChar * +s390_insn_vec_amodeop_emit(UChar *buf, const s390_insn *insn) +{ + UChar r1 = hregNumber(insn->variant.vec_amodeop.dst); + UChar v1 = hregNumber(insn->variant.vec_amodeop.op1); + s390_amode* op2 = insn->variant.vec_amodeop.op2; + + vassert(hregNumber(op2->x) == 0); + UChar b = hregNumber(op2->b); + UShort d = op2->d; + + + switch (insn->variant.vec_amodeop.tag) { + case S390_VEC_GET_ELEM: + return s390_emit_VLGV(buf, r1, b, d, v1, s390_getM_from_size(insn->size)); + default: goto fail; + } + + fail: + vpanic("s390_insn_vec_amodeop_emit"); +} + + +static UChar * +s390_insn_vec_amodeintop_emit(UChar *buf, const s390_insn *insn) +{ + UChar v1 = hregNumber(insn->variant.vec_amodeintop.dst); + s390_amode* op2 = insn->variant.vec_amodeintop.op2; + UChar r3 = hregNumber(insn->variant.vec_amodeintop.op3); + + vassert(hregNumber(op2->x) == 0); + UChar b = hregNumber(op2->b); + UShort d = op2->d; + + switch (insn->variant.vec_amodeintop.tag) { + case S390_VEC_SET_ELEM: + return s390_emit_VLVG(buf, v1, b, d, r3, s390_getM_from_size(insn->size)); + default: goto fail; + } + + fail: + vpanic("s390_insn_vec_amodeop_emit"); +} + + +static UChar * +s390_insn_vec_binop_emit(UChar *buf, const s390_insn *insn) +{ + s390_vec_binop_t tag = insn->variant.vec_binop.tag; + UChar size = insn->size; + UChar v1 = hregNumber(insn->variant.vec_binop.dst); + UChar v2 = hregNumber(insn->variant.vec_binop.op1); + UChar v3 = hregNumber(insn->variant.vec_binop.op2); + + switch (tag) { + case S390_VEC_PACK: + return s390_emit_VPK(buf, v1, v2, v3, s390_getM_from_size(size)); + case S390_VEC_PACK_SATURU: + return s390_emit_VPKLS(buf, v1, v2, v3, s390_getM_from_size(size)); + case S390_VEC_PACK_SATURS: + return s390_emit_VPKS(buf, v1, v2, v3, s390_getM_from_size(size)); + case S390_VEC_COMPARE_EQUAL: + return s390_emit_VCEQ(buf, v1, v2, v3, s390_getM_from_size(size)); + case S390_VEC_OR: + return s390_emit_VO(buf, v1, v2, v3); + case S390_VEC_XOR: + return s390_emit_VX(buf, v1, v2, v3); + case S390_VEC_AND: + return s390_emit_VN(buf, v1, v2, v3); + case S390_VEC_MERGEL: + return s390_emit_VMRH(buf, v1, v2, v3, s390_getM_from_size(size)); + case S390_VEC_MERGEH: + return s390_emit_VMRL(buf, v1, v2, v3, s390_getM_from_size(size)); + default: + goto fail; + } + + fail: + ppS390Instr(insn, True); + vpanic("s390_insn_vec_binop_emit"); + +} + + +static UChar * +s390_insn_vec_triop_emit(UChar *buf, const s390_insn *insn) +{ + s390_vec_triop_t tag = insn->variant.vec_triop.tag; + UChar v1 = hregNumber(insn->variant.vec_triop.dst); + UChar v2 = hregNumber(insn->variant.vec_triop.op1); + UChar v3 = hregNumber(insn->variant.vec_triop.op2); + UChar v4 = hregNumber(insn->variant.vec_triop.op3); + + switch (tag) { + case S390_VEC_PERM: + return s390_emit_VPERM(buf, v1, v2, v3, v4); + default: + goto fail; + } + + fail: + vpanic("s390_insn_vec_triop_emit"); + +} + + Int emit_S390Instr(Bool *is_profinc, UChar *buf, Int nbuf, const s390_insn *insn, Bool mode64, VexEndness endness_host, @@ -10012,6 +10750,21 @@ emit_S390Instr(Bool *is_profinc, UChar *buf, Int nbuf, const s390_insn *insn, end = s390_insn_xassisted_emit(buf, insn, disp_cp_xassisted); break; + case S390_INSN_VEC_AMODEOP: + end = s390_insn_vec_amodeop_emit(buf, insn); + break; + + case S390_INSN_VEC_AMODEINTOP: + end = s390_insn_vec_amodeintop_emit(buf, insn); + break; + + case S390_INSN_VEC_BINOP: + end = s390_insn_vec_binop_emit(buf, insn); + break; + + case S390_INSN_VEC_TRIOP: + end = s390_insn_vec_triop_emit(buf, insn); + break; fail: default: vpanic("emit_S390Instr"); diff --git a/VEX/priv/host_s390_defs.h b/VEX/priv/host_s390_defs.h index 254275a58d..de1ab19ae9 100644 --- a/VEX/priv/host_s390_defs.h +++ b/VEX/priv/host_s390_defs.h @@ -42,9 +42,11 @@ const HChar *s390_hreg_as_string(HReg); HReg s390_hreg_gpr(UInt regno); HReg s390_hreg_fpr(UInt regno); +HReg s390_hreg_vr(UInt regno); /* Dedicated registers */ HReg s390_hreg_guest_state_pointer(void); +HReg s390_hreg_stack_pointer(void); /* Given the index of a function argument, return the number of the @@ -86,6 +88,7 @@ s390_amode *s390_amode_b20(Int d, HReg b); s390_amode *s390_amode_bx12(Int d, HReg b, HReg x); s390_amode *s390_amode_bx20(Int d, HReg b, HReg x); s390_amode *s390_amode_for_guest_state(Int d); +s390_amode *s390_amode_for_stack_pointer(Int d); Bool s390_amode_is_sane(const s390_amode *); const HChar *s390_amode_as_string(const s390_amode *); @@ -160,7 +163,12 @@ typedef enum { S390_INSN_XINDIR, /* indirect transfer to guest address */ S390_INSN_XASSISTED, /* assisted transfer to guest address */ S390_INSN_EVCHECK, /* Event check */ - S390_INSN_PROFINC /* 64-bit profile counter increment */ + S390_INSN_PROFINC, /* 64-bit profile counter increment */ + S390_INSN_VEC_AMODEOP, + S390_INSN_VEC_AMODEINTOP, + S390_INSN_VEC_UNOP, + S390_INSN_VEC_BINOP, + S390_INSN_VEC_TRIOP } s390_insn_tag; @@ -186,7 +194,11 @@ typedef enum { S390_SIGN_EXTEND_8, S390_SIGN_EXTEND_16, S390_SIGN_EXTEND_32, - S390_NEGATE + S390_NEGATE, + S390_VEC_FILL, + S390_VEC_DUPLICATE, + S390_VEC_UNPACKLOWS, + S390_VEC_UNPACKLOWU } s390_unop_t; /* The kind of ternary BFP operations */ @@ -323,6 +335,34 @@ typedef enum { S390_DFP_COMPARE_EXP, } s390_dfp_cmp_t; +/* The vector operations with 2 operands one of them being amode */ +typedef enum { + S390_VEC_GET_ELEM +} s390_vec_amodeop_t; + +/* The vector operations with three (vector, amode and integer) operands */ +typedef enum { + S390_VEC_SET_ELEM +} s390_vec_amodeintop_t; + +/* The vector operations with two operands */ +typedef enum { + S390_VEC_PACK, + S390_VEC_PACK_SATURS, + S390_VEC_PACK_SATURU, + S390_VEC_COMPARE_EQUAL, + S390_VEC_OR, + S390_VEC_XOR, + S390_VEC_AND, + S390_VEC_MERGEL, + S390_VEC_MERGEH +} s390_vec_binop_t; + +/* The vector operations with three operands */ +typedef enum { + S390_VEC_PERM +} s390_vec_triop_t; + /* The details of a CDAS insn. Carved out to keep the size of s390_insn low */ typedef struct { @@ -619,7 +659,31 @@ typedef struct { installed later, post-translation, by patching it in, as it is not known at translation time. */ } profinc; - + struct { + s390_vec_amodeop_t tag; + HReg dst; /* 64-bit result */ + HReg op1; /* 128-bit operand */ + s390_amode *op2; /* amode operand */ + } vec_amodeop; + struct { + s390_vec_amodeintop_t tag; + HReg dst; /* 128-bit result */ + s390_amode *op2; /* amode operand */ + HReg op3; /* integer operand */ + } vec_amodeintop; + struct { + s390_vec_binop_t tag; + HReg dst; /* 128-bit result */ + HReg op1; /* 128-bit first operand */ + HReg op2; /* 128-bit second operand */ + } vec_binop; + struct { + s390_vec_triop_t tag; + HReg dst; /* 128-bit result */ + HReg op1; /* 128-bit first operand */ + HReg op2; /* 128-bit second operand */ + HReg op3; /* 128-bit third operand */ + } vec_triop; } variant; } s390_insn; @@ -727,6 +791,14 @@ s390_insn *s390_insn_xassisted(s390_cc_t cond, HReg dst, s390_amode *guest_IA, IRJumpKind kind); s390_insn *s390_insn_evcheck(s390_amode *counter, s390_amode *fail_addr); s390_insn *s390_insn_profinc(void); +s390_insn *s390_insn_vec_amodeop(UChar size, s390_vec_amodeop_t, HReg dst, + HReg op1, s390_amode* op2); +s390_insn *s390_insn_vec_amodeintop(UChar size, s390_vec_amodeintop_t, HReg dst, + s390_amode* op2, HReg op3); +s390_insn *s390_insn_vec_binop(UChar size, s390_vec_binop_t, HReg dst, HReg op1, + HReg op2); +s390_insn *s390_insn_vec_triop(UChar size, s390_vec_triop_t, HReg dst, HReg op1, + HReg op2, HReg op3); const HChar *s390_insn_as_string(const s390_insn *); @@ -799,6 +871,8 @@ extern UInt s390_host_hwcaps; (s390_host_hwcaps & (VEX_HWCAPS_S390X_LSC)) #define s390_host_has_pfpo \ (s390_host_hwcaps & (VEX_HWCAPS_S390X_PFPO)) +#define s390_host_has_vx \ + (s390_host_hwcaps & (VEX_HWCAPS_S390X_VX)) #endif /* ndef __VEX_HOST_S390_DEFS_H */ diff --git a/VEX/priv/host_s390_isel.c b/VEX/priv/host_s390_isel.c index 9322a0515d..ab71afeb2d 100644 --- a/VEX/priv/host_s390_isel.c +++ b/VEX/priv/host_s390_isel.c @@ -135,6 +135,7 @@ static HReg s390_isel_float_expr(ISelEnv *, IRExpr *); static void s390_isel_float128_expr(HReg *, HReg *, ISelEnv *, IRExpr *); static HReg s390_isel_dfp_expr(ISelEnv *, IRExpr *); static void s390_isel_dfp128_expr(HReg *, HReg *, ISelEnv *, IRExpr *); +static HReg s390_isel_vec_expr(ISelEnv *, IRExpr *); static Int @@ -242,6 +243,18 @@ newVRegF(ISelEnv *env) return mkVRegF(env->vreg_ctr++); } +/* Allocate a new virtual vector register */ +static HReg +mkVRegV(UInt ix) +{ + return mkHReg(/*virtual*/True, HRcVec128, /*encoding*/0, ix); +} + +static HReg +newVRegV(ISelEnv *env) +{ + return mkVRegV(env->vreg_ctr++); +} /* Construct a non-virtual general purpose register */ static __inline__ HReg @@ -482,6 +495,53 @@ get_const_value_as_ulong(const IRConst *con) } +/* Substract n from stack pointer. Assumes 0 <= n <= 256 && n % 8 == 0. */ +static void +sub_from_SP ( ISelEnv* env, UInt n ) +{ + HReg sp; + vassert( n < 256 && (n%8) == 0); + sp = s390_hreg_stack_pointer(); + addInstr(env, s390_insn_alu(sizeof(ULong), S390_ALU_SUB, sp, s390_opnd_imm(n))); +} + + +/* Substract n from stack pointer. Assumes 0 <= n <= 256 && n % 8 == 0. */ +static void +add_to_SP ( ISelEnv* env, UInt n ) +{ + HReg sp; + vassert(n < 256 && (n%8) == 0); + sp = s390_hreg_stack_pointer(); + addInstr(env, s390_insn_alu(sizeof(ULong), S390_ALU_ADD, sp, s390_opnd_imm(n))); +} + + +static HReg +vec_generate_zeroes(ISelEnv* env) +{ + HReg dst = newVRegV(env); + addInstr(env, s390_insn_unop(16, S390_VEC_FILL, dst, s390_opnd_imm(0x00))); + return dst; +} + +static HReg +vec_generate_ones(ISelEnv* env) +{ + HReg dst = newVRegV(env); + addInstr(env, s390_insn_unop(16, S390_VEC_FILL, dst, s390_opnd_imm(0xffff))); + return dst; +} + +static HReg +vec_do_notV128(ISelEnv* env, HReg arg) +{ + HReg dst = newVRegV(env); + addInstr(env, s390_insn_vec_binop(16, S390_VEC_XOR,dst, + arg, vec_generate_ones(env))); + return dst; +} + /* Call a helper (clean or dirty) Arguments must satisfy the following conditions: @@ -524,8 +584,7 @@ doHelperCall(/*OUT*/UInt *stackAdjustAfterCall, /* The return type can be I{64,32,16,8} or V{128,256}. In the latter two cases, it is expected that |args| will contain the - special node IRExpr_VECRET(). For s390, however, V128 and V256 return - values do not occur as we generally do not support vector types. + special node IRExpr_VECRET(). |args| may also contain IRExpr_GSPTR(), in which case the value in the guest state pointer register is passed as the @@ -561,7 +620,7 @@ doHelperCall(/*OUT*/UInt *stackAdjustAfterCall, ++arg_errors; vex_printf("calling %s: argument #%u has type ", callee->name, i); ppIRType(type); - vex_printf("; Ity_I64 is required\n"); + vex_printf("; Ity_I64 or Ity_V128 is required\n"); } } } @@ -571,7 +630,11 @@ doHelperCall(/*OUT*/UInt *stackAdjustAfterCall, /* If these fail, the IR is ill-formed */ vassert(nGSPTRs == 0 || nGSPTRs == 1); - vassert(nVECRETs == 0); + if (UNLIKELY(retTy == Ity_V128)) { + vassert(nVECRETs == 1); + } else { + vassert(nVECRETs == 0); + } argreg = 0; @@ -583,6 +646,11 @@ doHelperCall(/*OUT*/UInt *stackAdjustAfterCall, tmpregs[argreg] = newVRegI(env); addInstr(env, s390_insn_move(sizeof(ULong), tmpregs[argreg], s390_hreg_guest_state_pointer())); + } else if(UNLIKELY(arg->tag == Iex_VECRET)) { + /* Return vector via stack */ + tmpregs[argreg] = newVRegI(env); + sub_from_SP(env, sizeofIRType(Ity_V128)); + addInstr(env, s390_insn_move(sizeof(ULong), tmpregs[argreg], s390_hreg_stack_pointer())); } else { tmpregs[argreg] = s390_isel_int_expr(env, args[i]); } @@ -625,6 +693,10 @@ doHelperCall(/*OUT*/UInt *stackAdjustAfterCall, case Ity_I64: case Ity_I32: case Ity_I16: case Ity_I8: *retloc = mk_RetLoc_simple(RLPri_Int); break; + case Ity_V128: + *retloc = mk_RetLoc_spRel(RLPri_V128SpRel, 0); + *stackAdjustAfterCall = sizeof(V128); + break; default: /* IR can denote other possible return types, but we don't handle those here. */ @@ -1487,6 +1559,32 @@ s390_isel_int_expr_wrk(ISelEnv *env, IRExpr *expr) is_commutative = False; break; + case Iop_GetElem8x16: + case Iop_GetElem16x8: + case Iop_GetElem32x4: + case Iop_GetElem64x2:{ + HReg dst = newVRegI(env); + HReg vec = s390_isel_vec_expr(env, arg1); + s390_amode* operand = s390_isel_amode(env,IRExpr_Unop(Iop_8Uto64, arg2)); + switch (expr->Iex.Binop.op) { + case Iop_GetElem8x16: + size = 1; + break; + case Iop_GetElem16x8: + size = 2; + break; + case Iop_GetElem32x4: + size = 4; + break; + case Iop_GetElem64x2: + size = 8; + break; + default: + vpanic("s390_isel_int_expr: impossible Iop_GetElem type"); + } + addInstr(env, s390_insn_vec_amodeop(size, S390_VEC_GET_ELEM, dst, vec, operand)); + return dst; + } default: goto irreducible; } @@ -1680,6 +1778,38 @@ s390_isel_int_expr_wrk(ISelEnv *env, IRExpr *expr) return dst_hi; } + if(unop == Iop_V128to64 || unop == Iop_V128HIto64 || unop == Iop_V128to32) { + dst = newVRegI(env); + HReg vec = s390_isel_vec_expr(env, arg); + /* This is big-endian machine */ + Int off; + switch (unop) { + case Iop_V128HIto64: + off = 0; + break; + case Iop_V128to64: + off = 8; + break; + case Iop_V128to32: + off = 12; + break; + default: + ppIROp(unop); + vpanic("s390_isel_int_expr: unhandled V128toSMTH operation"); + } + s390_amode* m16_sp = s390_amode_for_stack_pointer(0); + s390_amode* off_sp = s390_amode_for_stack_pointer(off); + + /* We could use negative displacement but vector instructions + require 12bit unsigned ones. So we have to allocate space on + stack just for one load and free it after. */ + sub_from_SP(env, 16); + addInstr(env, s390_insn_store(sizeof(V128), m16_sp, vec)); + addInstr(env, s390_insn_load(sizeof(ULong), dst, off_sp)); + add_to_SP(env, 16); + return dst; + } + dst = newVRegI(env); /* Result goes into a new register */ opnd = s390_isel_int_expr_RMI(env, arg); /* Process the operand */ @@ -3503,6 +3633,334 @@ s390_isel_cc(ISelEnv *env, IRExpr *cond) } +/*---------------------------------------------------------*/ +/*--- ISEL: Vector expressions (128 bit) ---*/ +/*---------------------------------------------------------*/ + +static HReg +s390_isel_vec_expr_wrk(ISelEnv *env, IRExpr *expr) +{ + IRType ty = typeOfIRExpr(env->type_env, expr); + UChar size; + + vassert(ty == Ity_V128); + + size = sizeofIRType(ty); + + switch (expr->tag) { + case Iex_RdTmp: + /* Return the virtual register that holds the temporary. */ + return lookupIRTemp(env, expr->Iex.RdTmp.tmp); + + /* --------- LOAD --------- */ + case Iex_Load: { + HReg dst = newVRegV(env); + s390_amode *am = s390_isel_amode(env, expr->Iex.Load.addr); + + if (expr->Iex.Load.end != Iend_BE) + goto irreducible; + + addInstr(env, s390_insn_load(size, dst, am)); + + return dst; + } + + /* --------- GET --------- */ + case Iex_Get: { + HReg dst = newVRegV(env); + s390_amode *am = s390_amode_for_guest_state(expr->Iex.Get.offset); + + addInstr(env, s390_insn_load(size, dst, am)); + + return dst; + } + + case Iex_Const: { + HReg dst = newVRegV(env); + vassert(expr->Iex.Const.con->tag == Ico_V128); + + addInstr(env, s390_insn_unop(16, S390_VEC_FILL, dst, s390_opnd_imm(expr->Iex.Const.con->Ico.V128))); + return dst; + } + /* --------- UNARY OP --------- */ + case Iex_Unop: { + UChar size_for_int_arg = 0; + HReg dst; + HReg reg1; + s390_unop_t vec_op = 0; + IROp op = expr->Iex.Unop.op; + IRExpr* arg = expr->Iex.Unop.arg; + switch(op) { + case Iop_NotV128: + reg1 = s390_isel_vec_expr(env, arg); + return vec_do_notV128(env, reg1); + + case Iop_CmpNEZ8x16: + size = 1; + goto Iop_CmpNEZ_wrk; + case Iop_CmpNEZ16x8: + size = 2; + goto Iop_CmpNEZ_wrk; + case Iop_CmpNEZ32x4: + size = 4; + goto Iop_CmpNEZ_wrk; + case Iop_CmpNEZ64x2: + size = 8; + + Iop_CmpNEZ_wrk: { + dst = newVRegV(env); + reg1 = s390_isel_vec_expr(env, arg); + addInstr(env, s390_insn_vec_binop(size, S390_VEC_COMPARE_EQUAL, dst, + reg1, vec_generate_zeroes(env))); + return vec_do_notV128(env, dst); + } + + case Iop_Dup8x16: + size = size_for_int_arg = 1; + vec_op = S390_VEC_DUPLICATE; + goto Iop_V_int_wrk; + case Iop_Dup16x8: + size = size_for_int_arg = 2; + vec_op = S390_VEC_DUPLICATE; + goto Iop_V_int_wrk; + case Iop_Dup32x4: + size = size_for_int_arg = 4; + vec_op = S390_VEC_DUPLICATE; + goto Iop_V_int_wrk; + + case Iop_Widen8Sto16x8: + size = 1; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWS; + goto Iop_V_int_wrk; + case Iop_Widen16Sto32x4: + size = 2; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWS; + goto Iop_V_int_wrk; + case Iop_Widen32Sto64x2: + size = 4; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWS; + goto Iop_V_int_wrk; + case Iop_Widen8Uto16x8: + size = 1; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWU; + goto Iop_V_int_wrk; + case Iop_Widen16Uto32x4: + size = 2; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWU; + goto Iop_V_int_wrk; + case Iop_Widen32Uto64x2: + size = 4; + size_for_int_arg = 8; + vec_op = S390_VEC_UNPACKLOWU; + goto Iop_V_int_wrk; + + Iop_V_int_wrk: { + HReg vr1 = vec_generate_zeroes(env); + s390_amode* amode2 = s390_isel_amode(env, IRExpr_Const(IRConst_U64(0))); + reg1 = s390_isel_int_expr(env, arg); + + addInstr(env, + s390_insn_vec_amodeintop(size_for_int_arg, S390_VEC_SET_ELEM, + vr1, amode2, reg1)); + + dst = newVRegV(env); + addInstr(env, s390_insn_unop(size, vec_op, dst, s390_opnd_reg(vr1))); + return dst; + } + + default: + goto irreducible; + } + } + + /* --------- BINARY OP --------- */ + case Iex_Binop: { + HReg dst = newVRegV(env); + HReg reg1, reg2; + IROp op = expr->Iex.Binop.op; + s390_vec_binop_t vec_op = 0; + IRExpr* arg1 = expr->Iex.Binop.arg1; + IRExpr* arg2 = expr->Iex.Binop.arg2; + switch(op) { + case Iop_QNarrowBin16Uto8Ux16: + size = 2; + vec_op = S390_VEC_PACK_SATURU; + goto Iop_VV_wrk; + case Iop_QNarrowBin16Sto8Sx16: + size = 2; + vec_op = S390_VEC_PACK_SATURS; + goto Iop_VV_wrk; + case Iop_QNarrowBin32Uto16Ux8: + size = 4; + vec_op = S390_VEC_PACK_SATURU; + goto Iop_VV_wrk; + case Iop_QNarrowBin32Sto16Sx8: + size = 4; + vec_op = S390_VEC_PACK_SATURS; + goto Iop_VV_wrk; + case Iop_QNarrowBin64Uto32Ux4: + size = 8; + vec_op = S390_VEC_PACK_SATURU; + goto Iop_VV_wrk; + case Iop_QNarrowBin64Sto32Sx4: + size = 8; + vec_op = S390_VEC_PACK_SATURS; + goto Iop_VV_wrk; + + case Iop_NarrowBin16to8x16: + size = 2; + vec_op = S390_VEC_PACK; + goto Iop_VV_wrk; + case Iop_NarrowBin32to16x8: + size = 4; + vec_op = S390_VEC_PACK; + goto Iop_VV_wrk; + case Iop_NarrowBin64to32x4: + size = 8; + vec_op = S390_VEC_PACK; + goto Iop_VV_wrk; + + case Iop_OrV128: + size = 16; + vec_op = S390_VEC_OR; + goto Iop_VV_wrk; + + case Iop_XorV128: + size = 16; + vec_op = S390_VEC_XOR; + goto Iop_VV_wrk; + + case Iop_AndV128: + size = 16; + vec_op = S390_VEC_AND; + goto Iop_VV_wrk; + + case Iop_InterleaveLO8x16: + size = 1; + vec_op = S390_VEC_MERGEL; + goto Iop_VV_wrk; + case Iop_InterleaveLO16x8: + size = 2; + vec_op = S390_VEC_MERGEL; + goto Iop_VV_wrk; + case Iop_InterleaveLO32x4: + size = 4; + vec_op = S390_VEC_MERGEL; + goto Iop_VV_wrk; + case Iop_InterleaveLO64x2: + size = 8; + vec_op = S390_VEC_MERGEL; + goto Iop_VV_wrk; + + case Iop_InterleaveHI8x16: + size = 1; + vec_op = S390_VEC_MERGEH; + goto Iop_VV_wrk; + case Iop_InterleaveHI16x8: + size = 2; + vec_op = S390_VEC_MERGEH; + goto Iop_VV_wrk; + case Iop_InterleaveHI32x4: + size = 4; + vec_op = S390_VEC_MERGEH; + goto Iop_VV_wrk; + case Iop_InterleaveHI64x2: + size = 8; + vec_op = S390_VEC_MERGEH; + goto Iop_VV_wrk; + + Iop_VV_wrk: { + reg1 = s390_isel_vec_expr(env, arg1); + reg2 = s390_isel_vec_expr(env, arg2); + + addInstr(env, s390_insn_vec_binop(size, vec_op, + dst, reg1, reg2)); + + return dst; + } + + default: + goto irreducible; + } + } + + /* --------- TERNARY OP --------- */ + case Iex_Triop: { + HReg dst = newVRegV(env); + s390_amode* amode2; + HReg reg1, reg2, reg3; + IROp op = expr->Iex.Triop.details->op; + IRExpr* arg1 = expr->Iex.Triop.details->arg1; + IRExpr* arg2 = expr->Iex.Triop.details->arg2; + IRExpr* arg3 = expr->Iex.Triop.details->arg3; + switch (op) { + case Iop_SetElem8x16: + size = 1; + goto Iop_SetElem_wrk; + case Iop_SetElem16x8: + size = 2; + goto Iop_SetElem_wrk; + case Iop_SetElem32x4: + size = 4; + goto Iop_SetElem_wrk; + case Iop_SetElem64x2: { + size = 8; + + Iop_SetElem_wrk:{ + reg1 = s390_isel_vec_expr(env, arg1); + amode2 = s390_isel_amode(env, IRExpr_Unop(Iop_8Uto64, arg2)); + reg3 = s390_isel_int_expr(env, arg3); + + addInstr(env, s390_insn_move(16, dst, reg1)); + addInstr(env, s390_insn_vec_amodeintop(size, S390_VEC_SET_ELEM, + dst, amode2, reg3)); + return dst; + } + } + + case Iop_Perm8x16x2: + size = 16; + reg1 = s390_isel_vec_expr(env, arg1); + reg2 = s390_isel_vec_expr(env, arg2); + reg3 = s390_isel_vec_expr(env, arg3); + + addInstr(env, s390_insn_vec_triop(size, S390_VEC_PERM, + dst, reg1, reg2, reg3)); + return dst; + + default: + goto irreducible; + } + } + + default: + goto irreducible; + } + + /* We get here if no pattern matched. */ + irreducible: + ppIRExpr(expr); + vpanic("s390_isel_vec_expr: cannot reduce tree"); +} + +static HReg +s390_isel_vec_expr(ISelEnv *env, IRExpr *expr) +{ + HReg dst = s390_isel_vec_expr_wrk(env, expr); + + /* Sanity checks ... */ + vassert(hregClass(dst) == HRcVec128); + vassert(hregIsVirtual(dst)); + + return dst; +} + + /*---------------------------------------------------------*/ /*--- ISEL: Statements ---*/ /*---------------------------------------------------------*/ @@ -3572,6 +4030,9 @@ s390_isel_stmt(ISelEnv *env, IRStmt *stmt) /* Cannot occur. No such instruction */ vpanic("Ist_Store with 128-bit floating point data"); + case Ity_V128: + src = s390_isel_vec_expr(env, stmt->Ist.Store.data); + break; default: goto stmt_fail; } @@ -3718,6 +4179,9 @@ no_memcpy_put: src = s390_isel_dfp_expr(env, stmt->Ist.Put.data); break; + case Ity_V128: + src = s390_isel_vec_expr(env, stmt->Ist.Put.data); + break; default: goto stmt_fail; } @@ -3793,6 +4257,11 @@ no_memcpy_put: return; } + case Ity_V128: + src = s390_isel_vec_expr(env, stmt->Ist.WrTmp.data); + dst = lookupIRTemp(env, tmp); + break; + default: goto stmt_fail; } @@ -3837,7 +4306,7 @@ no_memcpy_put: retty = typeOfIRTemp(env->type_env, d->tmp); if (retty == Ity_I64 || retty == Ity_I32 - || retty == Ity_I16 || retty == Ity_I8) { + || retty == Ity_I16 || retty == Ity_I8 || retty == Ity_V128) { /* Move the returned value to the destination register */ HReg ret = make_gpr(S390_REGNO_RETURN_VALUE); @@ -3845,10 +4314,28 @@ no_memcpy_put: doHelperCall(&addToSp, &rloc, env, d->guard, d->cee, retty, d->args); vassert(is_sane_RetLoc(rloc)); - vassert(rloc.pri == RLPri_Int); - vassert(addToSp == 0); - addInstr(env, s390_insn_move(sizeof(ULong), dst, ret)); + switch(retty) + { + case Ity_I64: case Ity_I32: case Ity_I16: case Ity_I8: + vassert(rloc.pri == RLPri_Int); + vassert(addToSp == 0); + addInstr(env, s390_insn_move(sizeof(ULong), dst, ret)); + break; + case Ity_V128: + /* The returned value is on the stack, and rloc.spOff + tells us where. Fish it off the stack and then move + the stack pointer upwards to clear it, as directed by + doHelperCall. */ + vassert(rloc.pri == RLPri_V128SpRel); + vassert(addToSp == sizeof(V128)); + s390_amode* am = s390_amode_b12(rloc.spOff, s390_hreg_stack_pointer()); + addInstr(env, s390_insn_load(sizeof(V128), dst, am)); + add_to_SP(env, addToSp); + break; + default: + vpanic("s390_isel_stmt: invalid return type from dirty helper"); + } return; } break; @@ -4174,7 +4661,10 @@ iselSB_S390(const IRSB *bb, VexArch arch_host, const VexArchInfo *archinfo_host, hregHI = mkVRegF(j++); break; - case Ity_V128: /* fall through */ + case Ity_V128: + hreg = mkVRegV(j++); + break; + default: ppIRType(bb->tyenv->types[i]); vpanic("iselSB_S390: IRTemp type"); diff --git a/VEX/priv/ir_defs.c b/VEX/priv/ir_defs.c index 61ff837fc1..8627beb545 100644 --- a/VEX/priv/ir_defs.c +++ b/VEX/priv/ir_defs.c @@ -1091,6 +1091,11 @@ void ppIROp ( IROp op ) case Iop_GetElem32x4: vex_printf("GetElem32x4"); return; case Iop_GetElem64x2: vex_printf("GetElem64x2"); return; + case Iop_SetElem8x16: vex_printf("SetElem8x16"); return; + case Iop_SetElem16x8: vex_printf("SetElem16x8"); return; + case Iop_SetElem32x4: vex_printf("SetElem32x4"); return; + case Iop_SetElem64x2: vex_printf("SetElem64x2"); return; + case Iop_GetElem8x8: vex_printf("GetElem8x8"); return; case Iop_GetElem16x4: vex_printf("GetElem16x4"); return; case Iop_GetElem32x2: vex_printf("GetElem32x2"); return; @@ -1103,6 +1108,7 @@ void ppIROp ( IROp op ) case Iop_Perm8x16: vex_printf("Perm8x16"); return; case Iop_Perm32x4: vex_printf("Perm32x4"); return; + case Iop_Perm8x16x2: vex_printf("Perm8x16x2"); return; case Iop_Reverse8sIn16_x8: vex_printf("Reverse8sIn16_x8"); return; case Iop_Reverse8sIn32_x4: vex_printf("Reverse8sIn32_x4"); return; case Iop_Reverse16sIn32_x4: vex_printf("Reverse16sIn32_x4"); return; @@ -3119,6 +3125,9 @@ void typeOfPrimop ( IROp op, case Iop_MulI128by10ECarry: BINARY(Ity_V128,Ity_V128, Ity_V128); + case Iop_Perm8x16x2: + TERNARY(Ity_V128, Ity_V128, Ity_V128, Ity_V128); + case Iop_PolynomialMull8x8: case Iop_Mull8Ux8: case Iop_Mull8Sx8: case Iop_Mull16Ux4: case Iop_Mull16Sx4: @@ -3214,6 +3223,14 @@ void typeOfPrimop ( IROp op, BINARY(Ity_V128, Ity_I8, Ity_I32); case Iop_GetElem64x2: BINARY(Ity_V128, Ity_I8, Ity_I64); + case Iop_SetElem8x16: + TERNARY(Ity_V128, Ity_I8, Ity_I8, Ity_V128); + case Iop_SetElem16x8: + TERNARY(Ity_V128, Ity_I8, Ity_I16, Ity_V128); + case Iop_SetElem32x4: + TERNARY(Ity_V128, Ity_I8, Ity_I32, Ity_V128); + case Iop_SetElem64x2: + TERNARY(Ity_V128, Ity_I8, Ity_I64, Ity_V128); case Iop_GetElem8x8: BINARY(Ity_I64, Ity_I8, Ity_I8); case Iop_GetElem16x4: diff --git a/VEX/priv/main_main.c b/VEX/priv/main_main.c index 4ba1ab2523..41ad371564 100644 --- a/VEX/priv/main_main.c +++ b/VEX/priv/main_main.c @@ -1426,6 +1426,9 @@ const HChar* LibVEX_EmNote_string ( VexEmNote ew ) case EmFail_S390X_invalid_PFPO_function: return "The function code in GPR 0 for the PFPO instruction" " is invalid"; + case EmFail_S390X_vx: + return "Encountered an instruction that requires the vector facility.\n" + " That facility is not available on this host"; default: vpanic("LibVEX_EmNote_string: unknown warning"); } diff --git a/VEX/priv/s390_disasm.c b/VEX/priv/s390_disasm.c index 94bb90afa6..a7305c9546 100644 --- a/VEX/priv/s390_disasm.c +++ b/VEX/priv/s390_disasm.c @@ -135,6 +135,26 @@ cab_operand(const HChar *base, UInt mask) } +/* Return the name of a vector register for dis-assembly purposes. */ +static const HChar * +vr_operand(UInt archreg) +{ + static const HChar names[32][5] = { + "%v0", "%v1", "%v2", "%v3", + "%v4", "%v5", "%v6", "%v7", + "%v8", "%v9", "%v10", "%v11", + "%v16", "%v17", "%v18", "%v19", + "%v20", "%v21", "%v22", "%v23", + "%v24", "%v25", "%v26", "%v27", + "%v28", "%v29", "%v30", "%v31", + }; + + vassert(archreg < 32); + + return names[archreg]; +} + + /* Common function used to construct a mnemonic based on a condition code mask. */ static const HChar * @@ -284,6 +304,35 @@ udlb_operand(HChar *p, UInt d, UInt length, UInt b) } +/* An operand with a base register, an vector register, and a displacement. + If the displacement is signed, the rightmost 20 bit of D need to be + sign extended */ +static HChar * +dvb_operand(HChar *p, UInt d, UInt v, UInt b, Bool displacement_is_signed) +{ + if (displacement_is_signed) { + Int displ = (Int)(d << 12) >> 12; /* sign extend */ + + p += vex_sprintf(p, "%d", displ); + } else { + p += vex_sprintf(p, "%u", d); + } + if (v != 0) { + p += vex_sprintf(p, "(%s", vr_operand(v)); + if (b != 0) { + p += vex_sprintf(p, ",%s", gpr_operand(b)); + } + p += vex_sprintf(p, ")"); + } else { + if (b != 0) { + p += vex_sprintf(p, "(%s)", gpr_operand(b)); + } + } + + return p; +} + + /* The first argument is the command that says how to write the disassembled insn. It is understood that the mnemonic comes first and that arguments are separated by a ','. The command holds the arguments. Each argument is @@ -455,6 +504,21 @@ s390_disasm(UInt command, ...) } break; } + + case S390_ARG_VR: + p += vex_sprintf(p, "%s", vr_operand(va_arg(args, UInt))); + break; + + case S390_ARG_UDVB: { + UInt d, v, b; + + d = va_arg(args, UInt); + v = va_arg(args, UInt); + b = va_arg(args, UInt); + + p = dvb_operand(p, d, v, b, 0 /* signed_displacement */); + break; + } } separator = ','; diff --git a/VEX/priv/s390_disasm.h b/VEX/priv/s390_disasm.h index 696e52dd88..e7898981c5 100644 --- a/VEX/priv/s390_disasm.h +++ b/VEX/priv/s390_disasm.h @@ -66,7 +66,9 @@ enum { S390_ARG_UDLB = 9, S390_ARG_CABM = 10, S390_ARG_MNM = 11, - S390_ARG_XMNM = 12 + S390_ARG_XMNM = 12, + S390_ARG_VR = 13, + S390_ARG_UDVB = 14, }; /* The different kinds of extended mnemonics */ diff --git a/VEX/pub/libvex.h b/VEX/pub/libvex.h index cd616299de..24e5c98a6c 100644 --- a/VEX/pub/libvex.h +++ b/VEX/pub/libvex.h @@ -158,6 +158,7 @@ typedef #define VEX_HWCAPS_S390X_FPEXT (1<<15) /* Floating point extension facility */ #define VEX_HWCAPS_S390X_LSC (1<<16) /* Conditional load/store facility */ #define VEX_HWCAPS_S390X_PFPO (1<<17) /* Perform floating point ops facility */ +#define VEX_HWCAPS_S390X_VX (1<<18) /* Vector facility */ /* Special value representing all available s390x hwcaps */ #define VEX_HWCAPS_S390X_ALL (VEX_HWCAPS_S390X_LDISP | \ @@ -171,7 +172,8 @@ typedef VEX_HWCAPS_S390X_LSC | \ VEX_HWCAPS_S390X_ETF3 | \ VEX_HWCAPS_S390X_ETF2 | \ - VEX_HWCAPS_S390X_PFPO) + VEX_HWCAPS_S390X_PFPO | \ + VEX_HWCAPS_S390X_VX) #define VEX_HWCAPS_S390X(x) ((x) & ~VEX_S390X_MODEL_MASK) #define VEX_S390X_MODEL(x) ((x) & VEX_S390X_MODEL_MASK) diff --git a/VEX/pub/libvex_emnote.h b/VEX/pub/libvex_emnote.h index e597790644..4aaeac8fc9 100644 --- a/VEX/pub/libvex_emnote.h +++ b/VEX/pub/libvex_emnote.h @@ -120,6 +120,9 @@ typedef instruction is invalid */ EmFail_S390X_invalid_PFPO_function, + /* some insn needs vector facility which is not available on this host */ + EmFail_S390X_vx, + EmNote_NUMBER } VexEmNote; diff --git a/VEX/pub/libvex_guest_s390x.h b/VEX/pub/libvex_guest_s390x.h index 8cf0919c64..602f1a13bb 100644 --- a/VEX/pub/libvex_guest_s390x.h +++ b/VEX/pub/libvex_guest_s390x.h @@ -61,98 +61,122 @@ typedef struct { /* 60 */ UInt guest_a15; /*------------------------------------------------------------*/ -/*--- fpr registers ---*/ -/*------------------------------------------------------------*/ - - /* 64 */ ULong guest_f0; - /* 72 */ ULong guest_f1; - /* 80 */ ULong guest_f2; - /* 88 */ ULong guest_f3; - /* 96 */ ULong guest_f4; - /* 104 */ ULong guest_f5; - /* 112 */ ULong guest_f6; - /* 120 */ ULong guest_f7; - /* 128 */ ULong guest_f8; - /* 136 */ ULong guest_f9; - /* 144 */ ULong guest_f10; - /* 152 */ ULong guest_f11; - /* 160 */ ULong guest_f12; - /* 168 */ ULong guest_f13; - /* 176 */ ULong guest_f14; - /* 184 */ ULong guest_f15; +/*--- fpr & vr registers ---*/ +/*------------------------------------------------------------*/ + + /* + FPRs[0-15] are mapped to the first double words of VR's[0-15]. + According to documentation if we modify fpr1 with FP insn then the content of vr1's 64..128 + bits is unpredictable. If we modify 64..128 of vr1 then fpr1's value is unpredictable too. + In our implementation writing to one half of vr doesn't affect another part but + apllications shouldn't rely on it. + */ + + /* 64 */ V128 guest_v0; + /* 80 */ V128 guest_v1; + /* 96 */ V128 guest_v2; + /* 112 */ V128 guest_v3; + /* 128 */ V128 guest_v4; + /* 144 */ V128 guest_v5; + /* 160 */ V128 guest_v6; + /* 176 */ V128 guest_v7; + /* 192 */ V128 guest_v8; + /* 208 */ V128 guest_v9; + /* 224 */ V128 guest_v10; + /* 240 */ V128 guest_v11; + /* 256 */ V128 guest_v12; + /* 272 */ V128 guest_v13; + /* 288 */ V128 guest_v14; + /* 304 */ V128 guest_v15; + /* 320 */ V128 guest_v16; + /* 336 */ V128 guest_v17; + /* 352 */ V128 guest_v18; + /* 368 */ V128 guest_v19; + /* 384 */ V128 guest_v20; + /* 400 */ V128 guest_v21; + /* 416 */ V128 guest_v22; + /* 432 */ V128 guest_v23; + /* 448 */ V128 guest_v24; + /* 464 */ V128 guest_v25; + /* 480 */ V128 guest_v26; + /* 496 */ V128 guest_v27; + /* 512 */ V128 guest_v28; + /* 528 */ V128 guest_v29; + /* 544 */ V128 guest_v30; + /* 560 */ V128 guest_v31; /*------------------------------------------------------------*/ /*--- gpr registers ---*/ /*------------------------------------------------------------*/ - /* 192 */ ULong guest_r0; - /* 200 */ ULong guest_r1; - /* 208 */ ULong guest_r2; - /* 216 */ ULong guest_r3; - /* 224 */ ULong guest_r4; - /* 232 */ ULong guest_r5; - /* 240 */ ULong guest_r6; - /* 248 */ ULong guest_r7; - /* 256 */ ULong guest_r8; - /* 264 */ ULong guest_r9; - /* 272 */ ULong guest_r10; - /* 280 */ ULong guest_r11; - /* 288 */ ULong guest_r12; - /* 296 */ ULong guest_r13; - /* 304 */ ULong guest_r14; - /* 312 */ ULong guest_r15; + /* 568 */ ULong guest_r0; + /* 576 */ ULong guest_r1; + /* 584 */ ULong guest_r2; + /* 592 */ ULong guest_r3; + /* 600 */ ULong guest_r4; + /* 608 */ ULong guest_r5; + /* 616 */ ULong guest_r6; + /* 624 */ ULong guest_r7; + /* 632 */ ULong guest_r8; + /* 640 */ ULong guest_r9; + /* 648 */ ULong guest_r10; + /* 656 */ ULong guest_r11; + /* 664 */ ULong guest_r12; + /* 672 */ ULong guest_r13; + /* 680 */ ULong guest_r14; + /* 688 */ ULong guest_r15; /*------------------------------------------------------------*/ /*--- S390 miscellaneous registers ---*/ /*------------------------------------------------------------*/ - /* 320 */ ULong guest_counter; - /* 328 */ UInt guest_fpc; - /* 332 */ UChar unused[4]; /* 4-byte hole to get 8-byte alignment */ - /* 336 */ ULong guest_IA; + /* 696 */ ULong guest_counter; + /* 704 */ UInt guest_fpc; + /* 708 */ UChar unused[4]; /* 4-byte hole to get 8-byte alignment */ + /* 712 */ ULong guest_IA; /*------------------------------------------------------------*/ /*--- S390 pseudo registers ---*/ /*------------------------------------------------------------*/ - /* 344 */ ULong guest_SYSNO; + /* 720 */ ULong guest_SYSNO; /*------------------------------------------------------------*/ /*--- 4-word thunk used to calculate the condition code ---*/ /*------------------------------------------------------------*/ - /* 352 */ ULong guest_CC_OP; - /* 360 */ ULong guest_CC_DEP1; - /* 368 */ ULong guest_CC_DEP2; - /* 376 */ ULong guest_CC_NDEP; + /* 728 */ ULong guest_CC_OP; + /* 736 */ ULong guest_CC_DEP1; + /* 744 */ ULong guest_CC_DEP2; + /* 752 */ ULong guest_CC_NDEP; /*------------------------------------------------------------*/ /*--- Pseudo registers. Required by all architectures ---*/ /*------------------------------------------------------------*/ /* See comments at bottom of libvex.h */ - /* 384 */ ULong guest_NRADDR; - /* 392 */ ULong guest_CMSTART; - /* 400 */ ULong guest_CMLEN; + /* 760 */ ULong guest_NRADDR; + /* 768 */ ULong guest_CMSTART; + /* 776 */ ULong guest_CMLEN; /* Used when backing up to restart a syscall that has been interrupted by a signal. See also comment in libvex_ir.h */ - /* 408 */ ULong guest_IP_AT_SYSCALL; + /* 784 */ ULong guest_IP_AT_SYSCALL; /* Emulation notes; see comments in libvex_emnote.h */ - /* 416 */ UInt guest_EMNOTE; + /* 792 */ UInt guest_EMNOTE; /* For translation chaining */ - /* 420 */ UInt host_EvC_COUNTER; - /* 424 */ ULong host_EvC_FAILADDR; + /* 796 */ UInt host_EvC_COUNTER; + /* 800 */ ULong host_EvC_FAILADDR; /*------------------------------------------------------------*/ /*--- Force alignment to 16 bytes ---*/ /*------------------------------------------------------------*/ - /* 432 */ UChar padding[0]; + /* 808 */ UChar padding[0]; - /* 432 */ /* This is the size of the guest state */ + /* 816 */ /* This is the size of the guest state */ } VexGuestS390XState; diff --git a/VEX/pub/libvex_ir.h b/VEX/pub/libvex_ir.h index 5cc37e7df8..ed7d52b273 100644 --- a/VEX/pub/libvex_ir.h +++ b/VEX/pub/libvex_ir.h @@ -1799,9 +1799,11 @@ typedef Iop_CatEvenLanes8x16, Iop_CatEvenLanes16x8, Iop_CatEvenLanes32x4, /* GET elements of VECTOR - GET is binop (V128, I8) -> I */ + GET is binop (V128, I8) -> I + SET is triop (V128, I8, I) -> V128 */ /* Note: the arm back-end handles only constant second argument. */ Iop_GetElem8x16, Iop_GetElem16x8, Iop_GetElem32x4, Iop_GetElem64x2, + Iop_SetElem8x16, Iop_SetElem16x8, Iop_SetElem32x4, Iop_SetElem64x2, /* DUPLICATING -- copy value to all lanes */ Iop_Dup8x16, Iop_Dup16x8, Iop_Dup32x4, @@ -1830,6 +1832,12 @@ typedef Iop_Perm8x16, Iop_Perm32x4, /* ditto, except argR values are restricted to 0 .. 3 */ + /* same, but Triop (argL consists of two 128-bit parts) */ + /* correct range for argR values is 0..31 */ + /* (V128, V128, V128) -> V128 */ + /* (ArgL_first, ArgL_second, ArgR) -> result */ + Iop_Perm8x16x2, + /* MISC CONVERSION -- get high bits of each byte lane, a la x86/amd64 pmovmskb */ Iop_GetMSBs8x16, /* V128 -> I16 */ diff --git a/VEX/pub/libvex_s390x_common.h b/VEX/pub/libvex_s390x_common.h index 5b21b349e7..40185c2d9f 100644 --- a/VEX/pub/libvex_s390x_common.h +++ b/VEX/pub/libvex_s390x_common.h @@ -101,6 +101,7 @@ #define S390_FAC_CTREXE 50 // constrained transactional execution #define S390_FAC_TREXE 73 // transactional execution #define S390_FAC_MSA4 77 // message-security-assist 4 +#define S390_FAC_VX 128 // vector facility /*--------------------------------------------------------------*/ @@ -111,7 +112,7 @@ #define S390_NUM_GPRPARMS 5 /* Number of double words needed to store all facility bits. */ -#define S390_NUM_FACILITY_DW 2 +#define S390_NUM_FACILITY_DW 3 #endif /* __LIBVEX_PUB_S390X_H */ diff --git a/auxprogs/s390-check-opcodes.pl b/auxprogs/s390-check-opcodes.pl index 180a3bca6b..67687d203f 100755 --- a/auxprogs/s390-check-opcodes.pl +++ b/auxprogs/s390-check-opcodes.pl @@ -28,6 +28,108 @@ my %csv_implemented = (); my %toir_implemented = (); my %toir_decoded = (); +# "General" form of all theese vector mnemonics is handled. +# e.g. "vab %%v1, %%v2, %%v3" is equal to "va %%v1, %%v2, %%v3, 0" +# We exclude this "submnemonics" from handling and work with the "general" ones. +my @extended_mnemonics = ( + "bi", # extended mnemonics for bic + "va[bhfgq]", + "vacc[bhfgq]", + "vacccq", + "vacq", + "vavgl*[bhfg]", + "vcdl*gb", + "vceq[bhfg]s*", + "vchl*[bhfg]s*", + "vcl*gdb", + "vc[lt]z[bhfg]", + "vecl*[bhfg]", + "verim[bhfg]", + "verllv*[bhfg]", + "veslv*[bhfg]", + "vesrav*[bhfg]", + "vesrlv*[bhfg]", + "vfaez*[bhfg]s*", + "vfeez*[bhfg]s*", + "vfenez*[bhfg]s*", + "vfce[sd]bs*", + "vfchdbs*", + "vfche[sd]bs*", + "vfchsbs*", + "vfd[sd]b", + "vfa[sd]b", + "vfi[sd]b", + "vfke[sd]bs*", + "vfkhe*[sd]bs*", + "vflc[sd]b", + "vfll[sd]", + "[vw]flr[dx]", + "vfl[np][sd]b", + "vfm[as]*[sd]b", + "vfmax[sd]b", + "vfmin[sd]b", + "vfnm[as][sd]b", + "vfpso[sd]b", + "vfsq*[sd]b", + "vftci[sd]b", + "vgfma*[bhfg]", + "vgm[bhfg]", + "vistr[bhfg]s*", + "vlc[bhfg]", + "[vw]ldeb", + "[vw]ledb", + "vlgv[bhfg]", + "vllez[bhfg]", + "vllezlf", + "vlp[bhfg]", + "vlrep[bhfg]", + "vlvg[bhfg]", + "vmal*[eolh][bhfg]", + "vml*[eolh][bhf]", + "vm[nx]l*[bhfg]", + "vmr[lh][bhfg]", + "vmslg", + "vnot", + "(vone|vzero)", + "vpkl*[bhfg]", + "vpkl*s*[bhfg]s*", + "vpopct[bhfg]", + "vrepi*[bhgf]", + "vs[bhfgq]", + "vsbcbiq", + "vsbiq", + "vscbi[bhfgq]", + "vseg[bfh]", + "vstrcz*[bhf]s*", + "vsum(b|gh|gf|h|qf|qg)", + "vuplh[bhf]", + "vuph[bhf]", + "vupl(b|hw|f)", + "vupll[bhf]", + "wcdl*gb", + "wcl*gdb", + "wfa[sdx]b", + "wfch*e*[sdx]bs*", + "wf[cdi][sdx]b", + "wfkh*e*[sdx]bs*", + "wfk[sdx]b", + "wfl[clnp][sdx]b*", + "wfmax[sdx]b", + "wfmin[sdx]b", + "wfm[as]*[sdx]b", + "wfnm[as][sdx]b", + "wfpso[sdx]b", + "wftci[sdx]b", + "wfsq*[sdx]b", + "vfl[lr]" + ); + +# Compile excluded mnemonics into one regular expession to optimize speed. +# Also it simplifies the code. +my $extended_mnemonics_pattern = join '|', map "$_", @extended_mnemonics; +$extended_mnemonics_pattern = "($extended_mnemonics_pattern)"; +# print "extended_mnemonics_pattern: $extended_mnemonics_pattern\n"; + #---------------------------------------------------- # Read s390-opc.txt (binutils) @@ -76,21 +178,22 @@ while (my $line = ) { next if ($mnemonic eq "ldxbra"); # indistinguishable from ldxbr next if ($mnemonic eq "lexbra"); # indistinguishable from lexbr next if ($mnemonic eq "ledbra"); # indistinguishable from ledbr - next if ($mnemonic eq "cdgtra"); # indistinguishable from cdgtr + next if ($mnemonic eq "cdgtr"); # indistinguishable from cdgtra next if ($mnemonic eq "cxgtra"); # indistinguishable from cxgtr next if ($mnemonic eq "cgdtra"); # indistinguishable from cgdtr next if ($mnemonic eq "cgxtra"); # indistinguishable from cgxtr - next if ($mnemonic eq "fidbra"); # indistinguishable from fidbr - next if ($mnemonic eq "fiebra"); # indistinguishable from fiebr - next if ($mnemonic eq "fixbra"); # indistinguishable from fixbr - next if ($mnemonic eq "adtr"); # indistinguishable from adtra - next if ($mnemonic eq "axtr"); # indistinguishable from axtra - next if ($mnemonic eq "sdtr"); # indistinguishable from sdtra - next if ($mnemonic eq "sxtr"); # indistinguishable from sxtra - next if ($mnemonic eq "ddtr"); # indistinguishable from ddtra - next if ($mnemonic eq "dxtr"); # indistinguishable from dxtra - next if ($mnemonic eq "mdtr"); # indistinguishable from mdtra - next if ($mnemonic eq "mxtr"); # indistinguishable from mxtra + next if ($mnemonic eq "fidbr"); # indistinguishable from fidbra + next if ($mnemonic eq "fiebr"); # indistinguishable from fiebra + next if ($mnemonic eq "fixbr"); # indistinguishable from fixbra + next if ($mnemonic eq "adtr"); # indistinguishable from adtra + next if ($mnemonic eq "axtr"); # indistinguishable from axtra + next if ($mnemonic eq "sdtr"); # indistinguishable from sdtra + next if ($mnemonic eq "sxtr"); # indistinguishable from sxtra + next if ($mnemonic eq "ddtr"); # indistinguishable from ddtra + next if ($mnemonic eq "dxtr"); # indistinguishable from dxtra + next if ($mnemonic eq "mdtr"); # indistinguishable from mdtra + next if ($mnemonic eq "mxtr"); # indistinguishable from mxtra + next if ($mnemonic =~ /$extended_mnemonics_pattern/); $description =~ s/^[\s]+//g; # remove leading blanks $description =~ s/[\s]+$//g; # remove trailing blanks @@ -143,17 +246,18 @@ while (my $line = ) { next if ($mnemonic eq "ldxbra"); # indistinguishable from ldxbr next if ($mnemonic eq "lexbra"); # indistinguishable from lexbr next if ($mnemonic eq "ledbra"); # indistinguishable from ledbr - next if ($mnemonic eq "cdgtra"); # indistinguishable from cdgtr + next if ($mnemonic eq "cdgtr"); # indistinguishable from cdgtra next if ($mnemonic eq "cxgtra"); # indistinguishable from cxgtr next if ($mnemonic eq "cgdtra"); # indistinguishable from cgdtr next if ($mnemonic eq "cgxtra"); # indistinguishable from cgxtr - next if ($mnemonic eq "fidbra"); # indistinguishable from fidbr - next if ($mnemonic eq "fiebra"); # indistinguishable from fiebr - next if ($mnemonic eq "fixbra"); # indistinguishable from fixbr + next if ($mnemonic eq "fidbr"); # indistinguishable from fidbra + next if ($mnemonic eq "fiebr"); # indistinguishable from fiebra + next if ($mnemonic eq "fixbr"); # indistinguishable from fixbra next if ($mnemonic eq "adtr"); # indistinguishable from adtra next if ($mnemonic eq "sdtr"); # indistinguishable from sdtra next if ($mnemonic eq "ddtr"); # indistinguishable from ddtra next if ($mnemonic eq "mdtr"); # indistinguishable from mdtra + next if ($mnemonic =~ /$extended_mnemonics_pattern/); # Complain about duplicate entries. We don't want them. if ($csv_desc{$mnemonic}) { diff --git a/coregrind/m_coredump/coredump-elf.c b/coregrind/m_coredump/coredump-elf.c index 82de1d50c6..98cf921b15 100644 --- a/coregrind/m_coredump/coredump-elf.c +++ b/coregrind/m_coredump/coredump-elf.c @@ -495,7 +495,8 @@ static void fill_fpu(const ThreadState *tst, vki_elf_fpregset_t *fpu) I_die_here; #elif defined(VGP_s390x_linux) -# define DO(n) fpu->fprs[n].ui = arch->vex.guest_f##n + /* NOTE: The 16 FP registers map to the first 16 VSX registers. */ +# define DO(n) fpu->fprs[n].ui = *(const Double*)(&arch->vex.guest_v##n.w64[0]) DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7); DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15); # undef DO diff --git a/coregrind/m_gdbserver/valgrind-low-s390x.c b/coregrind/m_gdbserver/valgrind-low-s390x.c index 3985b09055..7bbb2e3723 100644 --- a/coregrind/m_gdbserver/valgrind-low-s390x.c +++ b/coregrind/m_gdbserver/valgrind-low-s390x.c @@ -165,23 +165,23 @@ void transfer_register (ThreadId tid, int abs_regno, void * buf, case 32: VG_(transfer) (&s390x->guest_a14, buf, dir, size, mod); break; case 33: VG_(transfer) (&s390x->guest_a15, buf, dir, size, mod); break; case 34: VG_(transfer) (&s390x->guest_fpc, buf, dir, size, mod); break; - case 35: VG_(transfer) (&s390x->guest_f0, buf, dir, size, mod); break; - case 36: VG_(transfer) (&s390x->guest_f1, buf, dir, size, mod); break; - case 37: VG_(transfer) (&s390x->guest_f2, buf, dir, size, mod); break; - case 38: VG_(transfer) (&s390x->guest_f3, buf, dir, size, mod); break; - case 39: VG_(transfer) (&s390x->guest_f4, buf, dir, size, mod); break; - case 40: VG_(transfer) (&s390x->guest_f5, buf, dir, size, mod); break; - case 41: VG_(transfer) (&s390x->guest_f6, buf, dir, size, mod); break; - case 42: VG_(transfer) (&s390x->guest_f7, buf, dir, size, mod); break; - case 43: VG_(transfer) (&s390x->guest_f8, buf, dir, size, mod); break; - case 44: VG_(transfer) (&s390x->guest_f9, buf, dir, size, mod); break; - case 45: VG_(transfer) (&s390x->guest_f10, buf, dir, size, mod); break; - case 46: VG_(transfer) (&s390x->guest_f11, buf, dir, size, mod); break; - case 47: VG_(transfer) (&s390x->guest_f12, buf, dir, size, mod); break; - case 48: VG_(transfer) (&s390x->guest_f13, buf, dir, size, mod); break; - case 49: VG_(transfer) (&s390x->guest_f14, buf, dir, size, mod); break; - case 50: VG_(transfer) (&s390x->guest_f15, buf, dir, size, mod); break; - case 51: *mod = False; break; //GDBTD??? { "orig_r2", 0, 64 }, + case 35: VG_(transfer) (&s390x->guest_v0, buf, dir, size, mod); break; + case 36: VG_(transfer) (&s390x->guest_v1.w64[0], buf, dir, size, mod); break; + case 37: VG_(transfer) (&s390x->guest_v2.w64[0], buf, dir, size, mod); break; + case 38: VG_(transfer) (&s390x->guest_v3.w64[0], buf, dir, size, mod); break; + case 39: VG_(transfer) (&s390x->guest_v4.w64[0], buf, dir, size, mod); break; + case 40: VG_(transfer) (&s390x->guest_v5.w64[0], buf, dir, size, mod); break; + case 41: VG_(transfer) (&s390x->guest_v6.w64[0], buf, dir, size, mod); break; + case 42: VG_(transfer) (&s390x->guest_v7.w64[0], buf, dir, size, mod); break; + case 43: VG_(transfer) (&s390x->guest_v8.w64[0], buf, dir, size, mod); break; + case 44: VG_(transfer) (&s390x->guest_v9.w64[0], buf, dir, size, mod); break; + case 45: VG_(transfer) (&s390x->guest_v10.w64[0], buf, dir, size, mod); break; + case 46: VG_(transfer) (&s390x->guest_v11.w64[0], buf, dir, size, mod); break; + case 47: VG_(transfer) (&s390x->guest_v12.w64[0], buf, dir, size, mod); break; + case 48: VG_(transfer) (&s390x->guest_v13.w64[0], buf, dir, size, mod); break; + case 49: VG_(transfer) (&s390x->guest_v14.w64[0], buf, dir, size, mod); break; + case 50: VG_(transfer) (&s390x->guest_v15.w64[0], buf, dir, size, mod); break; + case 51: *mod = False; break; //GDBTD??? { "orig_r2", 0, 64 }, default: vg_assert(0); } } diff --git a/coregrind/m_machine.c b/coregrind/m_machine.c index e9fefacc2c..f6ec7d52dc 100644 --- a/coregrind/m_machine.c +++ b/coregrind/m_machine.c @@ -1495,12 +1495,17 @@ Bool VG_(machine_get_hwcaps)( void ) { False, S390_FAC_FPEXT, VEX_HWCAPS_S390X_FPEXT, "FPEXT" }, { False, S390_FAC_LSC, VEX_HWCAPS_S390X_LSC, "LSC" }, { False, S390_FAC_PFPO, VEX_HWCAPS_S390X_PFPO, "PFPO" }, + { False, S390_FAC_VX, VEX_HWCAPS_S390X_VX, "VX" } }; /* Set hwcaps according to the detected facilities */ + UChar dw_number = 0; + UChar fac_bit = 0; for (i=0; i < sizeof fac_hwcaps / sizeof fac_hwcaps[0]; ++i) { - vg_assert(fac_hwcaps[i].facility_bit <= 63); // for now - if (hoststfle[0] & (1ULL << (63 - fac_hwcaps[i].facility_bit))) { + vg_assert(fac_hwcaps[i].facility_bit <= 191); // for now + dw_number = fac_hwcaps[i].facility_bit / 64; + fac_bit = fac_hwcaps[i].facility_bit % 64; + if (hoststfle[dw_number] & (1ULL << (63 - fac_bit))) { fac_hwcaps[i].installed = True; vai.hwcaps |= fac_hwcaps[i].hwcaps_bit; } diff --git a/coregrind/m_sigframe/sigframe-s390x-linux.c b/coregrind/m_sigframe/sigframe-s390x-linux.c index dc71d5d091..dbde62291e 100644 --- a/coregrind/m_sigframe/sigframe-s390x-linux.c +++ b/coregrind/m_sigframe/sigframe-s390x-linux.c @@ -178,22 +178,22 @@ static void save_sigregs(ThreadState *tst, _vki_sigregs *sigregs) sigregs->regs.acrs[14] = tst->arch.vex.guest_a14; sigregs->regs.acrs[15] = tst->arch.vex.guest_a15; - sigregs->fpregs.fprs[0] = tst->arch.vex.guest_f0; - sigregs->fpregs.fprs[1] = tst->arch.vex.guest_f1; - sigregs->fpregs.fprs[2] = tst->arch.vex.guest_f2; - sigregs->fpregs.fprs[3] = tst->arch.vex.guest_f3; - sigregs->fpregs.fprs[4] = tst->arch.vex.guest_f4; - sigregs->fpregs.fprs[5] = tst->arch.vex.guest_f5; - sigregs->fpregs.fprs[6] = tst->arch.vex.guest_f6; - sigregs->fpregs.fprs[7] = tst->arch.vex.guest_f7; - sigregs->fpregs.fprs[8] = tst->arch.vex.guest_f8; - sigregs->fpregs.fprs[9] = tst->arch.vex.guest_f9; - sigregs->fpregs.fprs[10] = tst->arch.vex.guest_f10; - sigregs->fpregs.fprs[11] = tst->arch.vex.guest_f11; - sigregs->fpregs.fprs[12] = tst->arch.vex.guest_f12; - sigregs->fpregs.fprs[13] = tst->arch.vex.guest_f13; - sigregs->fpregs.fprs[14] = tst->arch.vex.guest_f14; - sigregs->fpregs.fprs[15] = tst->arch.vex.guest_f15; + sigregs->fpregs.fprs[0] = *((const Double *) &tst->arch.vex.guest_v0.w64[0]); + sigregs->fpregs.fprs[1] = *((const Double *) &tst->arch.vex.guest_v1.w64[0]); + sigregs->fpregs.fprs[2] = *((const Double *) &tst->arch.vex.guest_v2.w64[0]); + sigregs->fpregs.fprs[3] = *((const Double *) &tst->arch.vex.guest_v3.w64[0]); + sigregs->fpregs.fprs[4] = *((const Double *) &tst->arch.vex.guest_v4.w64[0]); + sigregs->fpregs.fprs[5] = *((const Double *) &tst->arch.vex.guest_v5.w64[0]); + sigregs->fpregs.fprs[6] = *((const Double *) &tst->arch.vex.guest_v6.w64[0]); + sigregs->fpregs.fprs[7] = *((const Double *) &tst->arch.vex.guest_v7.w64[0]); + sigregs->fpregs.fprs[8] = *((const Double *) &tst->arch.vex.guest_v8.w64[0]); + sigregs->fpregs.fprs[9] = *((const Double *) &tst->arch.vex.guest_v9.w64[0]); + sigregs->fpregs.fprs[10] = *((const Double *) &tst->arch.vex.guest_v10.w64[0]); + sigregs->fpregs.fprs[11] = *((const Double *) &tst->arch.vex.guest_v11.w64[0]); + sigregs->fpregs.fprs[12] = *((const Double *) &tst->arch.vex.guest_v12.w64[0]); + sigregs->fpregs.fprs[13] = *((const Double *) &tst->arch.vex.guest_v13.w64[0]); + sigregs->fpregs.fprs[14] = *((const Double *) &tst->arch.vex.guest_v14.w64[0]); + sigregs->fpregs.fprs[15] = *((const Double *) &tst->arch.vex.guest_v15.w64[0]); sigregs->fpregs.fpc = tst->arch.vex.guest_fpc; sigregs->regs.psw.addr = tst->arch.vex.guest_IA; @@ -237,22 +237,22 @@ static void restore_sigregs(ThreadState *tst, _vki_sigregs *sigregs) tst->arch.vex.guest_a14 = sigregs->regs.acrs[14]; tst->arch.vex.guest_a15 = sigregs->regs.acrs[15]; - tst->arch.vex.guest_f0 = sigregs->fpregs.fprs[0]; - tst->arch.vex.guest_f1 = sigregs->fpregs.fprs[1]; - tst->arch.vex.guest_f2 = sigregs->fpregs.fprs[2]; - tst->arch.vex.guest_f3 = sigregs->fpregs.fprs[3]; - tst->arch.vex.guest_f4 = sigregs->fpregs.fprs[4]; - tst->arch.vex.guest_f5 = sigregs->fpregs.fprs[5]; - tst->arch.vex.guest_f6 = sigregs->fpregs.fprs[6]; - tst->arch.vex.guest_f7 = sigregs->fpregs.fprs[7]; - tst->arch.vex.guest_f8 = sigregs->fpregs.fprs[8]; - tst->arch.vex.guest_f9 = sigregs->fpregs.fprs[9]; - tst->arch.vex.guest_f10 = sigregs->fpregs.fprs[10]; - tst->arch.vex.guest_f11 = sigregs->fpregs.fprs[11]; - tst->arch.vex.guest_f12 = sigregs->fpregs.fprs[12]; - tst->arch.vex.guest_f13 = sigregs->fpregs.fprs[13]; - tst->arch.vex.guest_f14 = sigregs->fpregs.fprs[14]; - tst->arch.vex.guest_f15 = sigregs->fpregs.fprs[15]; + *((Double *) &tst->arch.vex.guest_v0.w64[0]) = sigregs->fpregs.fprs[0]; + *((Double *) &tst->arch.vex.guest_v1.w64[0]) = sigregs->fpregs.fprs[1]; + *((Double *) &tst->arch.vex.guest_v2.w64[0]) = sigregs->fpregs.fprs[2]; + *((Double *) &tst->arch.vex.guest_v3.w64[0]) = sigregs->fpregs.fprs[3]; + *((Double *) &tst->arch.vex.guest_v4.w64[0]) = sigregs->fpregs.fprs[4]; + *((Double *) &tst->arch.vex.guest_v5.w64[0]) = sigregs->fpregs.fprs[5]; + *((Double *) &tst->arch.vex.guest_v6.w64[0]) = sigregs->fpregs.fprs[6]; + *((Double *) &tst->arch.vex.guest_v7.w64[0]) = sigregs->fpregs.fprs[7]; + *((Double *) &tst->arch.vex.guest_v8.w64[0]) = sigregs->fpregs.fprs[8]; + *((Double *) &tst->arch.vex.guest_v9.w64[0]) = sigregs->fpregs.fprs[9]; + *((Double *) &tst->arch.vex.guest_v10.w64[0]) = sigregs->fpregs.fprs[10]; + *((Double *) &tst->arch.vex.guest_v11.w64[0]) = sigregs->fpregs.fprs[11]; + *((Double *) &tst->arch.vex.guest_v12.w64[0]) = sigregs->fpregs.fprs[12]; + *((Double *) &tst->arch.vex.guest_v13.w64[0]) = sigregs->fpregs.fprs[13]; + *((Double *) &tst->arch.vex.guest_v14.w64[0]) = sigregs->fpregs.fprs[14]; + *((Double *) &tst->arch.vex.guest_v15.w64[0]) = sigregs->fpregs.fprs[15]; tst->arch.vex.guest_fpc = sigregs->fpregs.fpc; tst->arch.vex.guest_IA = sigregs->regs.psw.addr; diff --git a/docs/internals/s390-opcodes.csv b/docs/internals/s390-opcodes.csv index 20aaa07b80..36becfd073 100644 --- a/docs/internals/s390-opcodes.csv +++ b/docs/internals/s390-opcodes.csv @@ -929,9 +929,9 @@ clfxbr,"convert to 32 bit fixed logical from extended bfp with rounding mode",im clgebr,"convert to 64 bit fixed logical from short bfp with rounding mode",implemented, clgdbr,"convert to 64 bit fixed logical from long bfp with rounding mode",implemented, clgxbr,"convert to 64 bit fixed logical from extended bfp with rounding mode",implemented, -fiebra,"load fp integer short bfp with rounding mode","not implemented","new to z196" -fidbra,"load fp integer long bfp with rounding mode","not implemented","new to z196" -fixbra,"load fp integer extended bfp with rounding mode","not implemented","new to z196" +fiebra,"load fp integer short bfp with inexact suppression",implemented,"new to z196" +fidbra,"load fp integer long bfp with inexact suppression",implemented,"new to z196" +fixbra,"load fp integer extended bfp with inexact suppression",implemented,"new to z196" ledbra,"load rounded short/long bfp to short/long bfp with rounding mode",implemented, ldxbra,"load rounded long/extended bfp to long/extended bfp with rounding mode",implemented, lexbra,"load rounded short/extended bfp to short/extended bfp with rounding mode",implemented, @@ -980,12 +980,12 @@ cdzt,"convert from zoned long","not implemented",zEC12, cxzt,"convert from zoned extended","not implemented",zEC12, czdt,"convert to zoned long","not implemented",zEC12, czxt,"convert to zoned extended","not implemented",zEC12, -vfsdb,"vector fp subtract","not implemented",z13 +vfsdb,"vector fp subtract long","not implemented",z13 vlpf,"vector load positive word","not implemented",z13 verllh,"vector element rotate left logical mem halfword","not implemented",z13 vzero,"vector set to zero","not implemented",z13 vmalof,"vector multiply and add logical odd word","not implemented",z13 -vleif,"vector load word element immediate","not implemented",z13 +vleif,"vector load word element immediate",implemented,z13 vlpb,"vector load positive byte","not implemented",z13 vmxlh,"vector maximum logical halfword","not implemented",z13 vpksfs,"vector pack saturate word","not implemented",z13 @@ -993,9 +993,9 @@ vfenezh,"vector find element not equal halfword","not implemented",z13 vecl,"vector element compare logical","not implemented",z13 verimb,"vector element rotate and insert under mask byte","not implemented",z13 vaccq,"vector add compute carry quadword","not implemented",z13 -vleh,"vector load halfword element","not implemented",z13 -vst,"vector store","not implemented",z13 -vsteg,"vector store double word element","not implemented",z13 +vleh,"vector load halfword element","implemented",z13 +vst,"vector store","implemented",z13 +vsteg,"vector store double word element","implemented",z13 vmnf,"vector minimum word","not implemented",z13 vavgl,"vector average logical","not implemented",z13 vfpsodb,"vector fp perform sign operation","not implemented",z13 @@ -1005,95 +1005,95 @@ vldeb,"vector fp load lengthened","not implemented",z13 vclzg,"vector count leading zeros doubleword","not implemented",z13 vecg,"vector element compare double word","not implemented",z13 vpksgs,"vector pack saturate double word","not implemented",z13 -vsel,"vector select","not implemented",z13 -vllezb,"vector load logical byte element and zero","not implemented",z13 +vsel,"vector select","implemented",z13 +vllezb,"vector load logical byte element and zero","implemented",z13 vfaezh,"vector find any element equal","not implemented",z13 vftci,"vector fp test data class immediate","not implemented",z13 veclb,"vector element compare logical byte","not implemented",z13 vuplhw,"vector unpack low halfword","not implemented",z13 veslvb,"vector element shift left reg byte","not implemented",z13 -vuplh,"vector unpack logical high","not implemented",z13 +vuplh,"vector unpack logical high","implemented",z13 vlde,"vector fp load lengthened","not implemented",z13 vmoh,"vector multiply odd halfword","not implemented",z13 vfaehs,"vector find any element equal","not implemented",z13 vftcidb,"vector fp test data class immediate","not implemented",z13 vaq,"vector add quad word","not implemented",z13 -vlgvh,"vector load gr from vr halfword element","not implemented",z13 +vlgvh,"vector load gr from vr halfword element","implemented",z13 vchlg,"vector compare high logical double word","not implemented",z13 -vlvgp,"vector load VR from GRs disjoint","not implemented",z13 +vlvgp,"vector load VR from GRs disjoint","implemented",z13 vceqg,"vector compare equal double word","not implemented",z13 vfeezh,"vector find element equal halfword","not implemented",z13 -vlvgf,"vector load VR word element from GR","not implemented",z13 -vsteb,"vector store byte element","not implemented",z13 -vgmb,"vector generate mask byte","not implemented",z13 -vpklsf,"vector pack logical saturate word","not implemented",z13 +vlvgf,"vector load VR word element from GR","implemented",z13 +vsteb,"vector store byte element","implemented",z13 +vgmb,"vector generate mask byte","implemented",z13 +vpklsf,"vector pack logical saturate word","implemented",z13 vmao,"vector multiply and add odd","not implemented",z13 vchf,"vector compare high word","not implemented",z13 vesraf,"vector element shift right arithmetic mem word","not implemented",z13 vsbiq,"vector subtract with borrow indication quadword","not implemented",z13 -vuphb,"vector unpack high byte","not implemented",z13 +vuphb,"vector unpack high byte","implemented",z13 vgfmb,"vector galois field multiply sum byte","not implemented",z13 -vrepih,"vector replicate immediate halfword","not implemented",z13 +vrepih,"vector replicate immediate halfword","implemented",z13 vcdlg,"vector fp convert from logical 64 bit","not implemented",z13 cxpt,"convert from packed to extended dfp","not implemented",z13 vceqb,"vector compare equal byte","not implemented",z13 vstrczfs,"vector string range compare word","not implemented",z13 vpklshs,"vector pack logical saturate halfword","not implemented",z13 -vlvgb,"vector load VR byte element from GR","not implemented",z13 +vlvgb,"vector load VR byte element from GR","implemented",z13 lcbb,"load count to block boundary","not implemented",z13 vlcf,"vector load complement word","not implemented",z13 -vlvg,"vector load VR element from GR","not implemented",z13 +vlvg,"vector load VR element from GR","implemented",z13 vmalef,"vector multiply and add logical even word","not implemented",z13 -vn,"vector and","not implemented",z13 +vn,"vector and","implemented",z13 vmae,"vector multiply and add even","not implemented",z13 vstrc,"vector string range compare","not implemented",z13 vfcedb,"vector fp compare equal","not implemented",z13 vgfm,"vector galois field multiply sum","not implemented",z13 -vlrepb,"vector load and replicate byte elements","not implemented",z13 +vlrepb,"vector load and replicate byte elements","implemented",z13 vgfmag,"vector galois field multiply sum and accumulate doubleword","not implemented",z13 vflndb,"vector fp perform sign operation","not implemented",z13 vmaeb,"vector multiply and add even byte","not implemented",z13 vpkg,"vector pack double word","not implemented",z13 vsb,"vector subtract byte","not implemented",z13 vchl,"vector compare high logical","not implemented",z13 -vlvgh,"vector load VR halfword element from GR","not implemented",z13 +vlvgh,"vector load VR halfword element from GR","implemented",z13 locghi,"load halfword immediate on condition into 64 bit gpr","not implemented",z13 vmalb,"vector multiply and add low byte","not implemented",z13 vchlgs,"vector compare high logical double word","not implemented",z13 -vstef,"vector store word element","not implemented",z13 +vstef,"vector store word element","implemented",z13 lzrf,"load and zero rightmost byte 32->32","not implemented",z13 -vmrlh,"vector merge low halfword","not implemented",z13 +vmrlh,"vector merge low halfword","implemented",z13 vchbs,"vector compare high byte","not implemented",z13 vesrlf,"vector element shift right logical mem word","not implemented",z13 vmxf,"vector maximum word","not implemented",z13 -vgmh,"vector generate mask halfword","not implemented",z13 +vgmh,"vector generate mask halfword","implemented",z13 vfenezb,"vector find element not equal byte","not implemented",z13 vpklsgs,"vector pack logical saturate double word","not implemented",z13 -vpksg,"vector pack saturate double word","not implemented",z13 +vpksg,"vector pack saturate double word","implemented",z13 vfaeh,"vector find any element equal halfword","not implemented",z13 vmlof,"vector multiply logical odd word","not implemented",z13 vmahh,"vector multiply and add high halfword","not implemented",z13 -vx,"vector exclusive or","not implemented",z13 +vx,"vector exclusive or","implemented",z13 vchlfs,"vector compare high logical word","not implemented",z13 vacccq,"vector add with carry compute carry quadword","not implemented",z13 vchb,"vector compare high byte","not implemented",z13 vmaloh,"vector multiply and add logical odd halfword","not implemented",z13 vmleh,"vector multiply logical even halfword","not implemented",z13 verimh,"vector element rotate and insert under mask halfword","not implemented",z13 -vlrepf,"vector load and replicate word elements","not implemented",z13 +vlrepf,"vector load and replicate word elements","implemented",z13 vgfmg,"vector galois field multiply sum doubleword","not implemented",z13 -vpklsg,"vector pack logical saturate double word","not implemented",z13 +vpklsg,"vector pack logical saturate double word","implemented",z13 vesrlvf,"vector element shift right logical reg word","not implemented",z13 -vrepg,"vector replicate double word","not implemented",z13 +vrepg,"vector replicate double word","implemented",z13 vmalob,"vector multiply and add logical odd byte","not implemented",z13 vmxb,"vector maximum byte","not implemented",z13 vmnl,"vector minimum logical","not implemented",z13 vmng,"vector minimum doubleword","not implemented",z13 vchlb,"vector compare high logical byte","not implemented",z13 wfadb,"vector fp add","not implemented",z13 -vmrl,"vector merge low","not implemented",z13 +vmrl,"vector merge low","implemented",z13 wfk,"vector fp compare and signal scalar","not implemented",z13 -vno,"vector nor","not implemented",z13 +vno,"vector nor","implemented",z13 vstrcf,"vector string range compare word","not implemented",z13 vfmsdb,"vector fp multiply and subtract","not implemented",z13 vavgh,"vector average half word","not implemented",z13 @@ -1101,29 +1101,29 @@ vchlhs,"vector compare high logical half word","not implemented",z13 vah,"vector add halfword","not implemented",z13 vmalhh,"vector multiply and add logical high halfword","not implemented",z13 wldeb,"vector fp load lengthened","not implemented",z13 -vmrh,"vector merge high","not implemented",z13 +vmrh,"vector merge high","implemented",z13 vclgdb,"vector fp convert to logical 64 bit","not implemented",z13 wfsqdb,"vector fp square root","not implemented",z13 vpopct,"vector population count","not implemented",z13 vfenef,"vector find element not equal word","not implemented",z13 vgfmf,"vector galois field multiply sum word","not implemented",z13 -vgmf,"vector generate mask word","not implemented",z13 -vleg,"vector load double word element","not implemented",z13 +vgmf,"vector generate mask word","implemented",z13 +vleg,"vector load double word element","implemented",z13 vmn,"vector minimum","not implemented",z13 -vrepi,"vector replicate immediate","not implemented",z13 -vsegb,"vector sign extend byte to double word","not implemented",z13 +vrepi,"vector replicate immediate","implemented",z13 +vsegb,"vector sign extend byte to double word","implemented",z13 cpxt,"convert from extended dfp to packed","not implemented",z13 wftcidb,"vector fp test data class immediate","not implemented",z13 wfchedbs,"vector fp compare high or equal","not implemented",z13 -vpks,"vector pack saturate","not implemented",z13 +vpks,"vector pack saturate","implemented",z13 veslg,"vector element shift left mem doubleword","not implemented",z13 -vupllb,"vector unpack logical low byte","not implemented",z13 +vupllb,"vector unpack logical low byte","implemented",z13 vscbig,"vector subtract compute borrow indication doubleword","not implemented",z13 -vsegh,"vector sign extend halfword to double word","not implemented",z13 +vsegh,"vector sign extend halfword to double word","implemented",z13 vsumb,"vector sum across word - byte elements","not implemented",z13 -vgeg,"vector gather element 8 byte elements","not implemented",z13 +vgeg,"vector gather element 8 byte elements","implemented",z13 vcgd,"vector fp convert to fixed 64 bit","not implemented",z13 -vuplhb,"vector unpack logical high byte","not implemented",z13 +vuplhb,"vector unpack logical high byte","implemented",z13 verllv,"vector element rotate left logical reg","not implemented",z13 vavgb,"vector average byte","not implemented",z13 veclh,"vector element compare logical half word","not implemented",z13 @@ -1132,7 +1132,7 @@ vesravb,"vector element shift right arithmetic reg byte","not implemented",z13 vmaleb,"vector multiply and add logical even byte","not implemented",z13 vuplf,"vector unpack low word","not implemented",z13 vsbi,"vector subtract with borrow indication","not implemented",z13 -vupll,"vector unpack logical low","not implemented",z13 +vupll,"vector unpack logical low","implemented",z13 vmrhh,"vector merge high halfword","not implemented",z13 vfenezbs,"vector find element not equal byte","not implemented",z13 vmhb,"vector multiply high byte","not implemented",z13 @@ -1144,19 +1144,19 @@ wfcedb,"vector fp compare equal","not implemented",z13 vscbih,"vector subtract compute borrow indication halfword","not implemented",z13 vlch,"vector load complement halfword","not implemented",z13 vfenebs,"vector find element not equal byte","not implemented",z13 -vpklsh,"vector pack logical saturate halfword","not implemented",z13 -vlgv,"vector load gr from vr element","not implemented",z13 +vpklsh,"vector pack logical saturate halfword","implemented",z13 +vlgv,"vector load gr from vr element","implemented",z13 vchfs,"vector compare high word","not implemented",z13 vctzb,"vector count trailing zeros byte","not implemented",z13 vfaef,"vector find any element equal word","not implemented",z13 vstrch,"vector string range compare halfword","not implemented",z13 wfidb,"vector load fp integer","not implemented",z13 vmrhb,"vector merge high byte","not implemented",z13 -vuph,"vector unpack high","not implemented",z13 -vperm,"vector permute","not implemented",z13 -vrep,"vector replicate","not implemented",z13 +vuph,"vector unpack high","implemented",z13 +vperm,"vector permute","implemented",z13 +vrep,"vector replicate","implemented",z13 vmalhb,"vector multiply and add logical high byte","not implemented",z13 -vleib,"vector load byte element immediate","not implemented",z13 +vleib,"vector load byte element immediate","implemented",z13 vavg,"vector average","not implemented",z13 vfenefs,"vector find element not equal word","not implemented",z13 vsumh,"vector sum across word - halfword elements","not implemented",z13 @@ -1164,20 +1164,20 @@ vchh,"vector compare high half word","not implemented",z13 wcdgb,"vector fp convert from fixed 64 bit","not implemented",z13 verllvb,"vector element rotate left logical reg byte","not implemented",z13 vec,"vector element compare","not implemented",z13 -vpdi,"vector permute double word immediate","not implemented",z13 -vfchedb,"vector fp compare high or equal","not implemented",z13 +vpdi,"vector permute double word immediate",implemented,z13 +vfchedb,"vector fp compare high or equal long","not implemented",z13 vchlh,"vector compare high logical half word","not implemented",z13 vmaleh,"vector multiply and add logical even halfword","not implemented",z13 vstrcb,"vector string range compare byte","not implemented",z13 vsumqg,"vector sum across quadword - doubleword elements","not implemented",z13 vlc,"vector load complement","not implemented",z13 -vlreph,"vector load and replicate halfword elements","not implemented",z13 +vlreph,"vector load and replicate halfword elements",implemented,z13 vistrb,"vector isolate string byte","not implemented",z13 vmo,"vector multiply odd","not implemented",z13 vmxg,"vector maximum doubleword","not implemented",z13 vsrab,"vector shift right arithmetic by byte","not implemented",z13 vsbcbiq,"vector subtract with borrow compute borrow indication quadword","not implemented",z13 -wfchdb,"vector fp compare high","not implemented",z13 +wfchdb,"vector fp compare high long","not implemented",z13 vmlhf,"vector multiply logical high word","not implemented",z13 vesra,"vector element shift right arithmetic mem","not implemented",z13 vmnh,"vector minimum halfword","not implemented",z13 @@ -1185,60 +1185,60 @@ vled,"vector fp load rounded","not implemented",z13 vstrczbs,"vector string range compare byte","not implemented",z13 vaccb,"vector add compute carry byte","not implemented",z13 vmahf,"vector multiply and add high word","not implemented",z13 -wfcedbs,"vector fp compare equal","not implemented",z13 +wfcedbs,"vector fp compare equal long","not implemented",z13 vmeh,"vector multiply even halfword","not implemented",z13 vclzb,"vector count leading zeros byte","not implemented",z13 vmh,"vector multiply high","not implemented",z13 -vllez,"vector load logical element and zero","not implemented",z13 +vllez,"vector load logical element and zero",implemented,z13 vnc,"vector and with complement","not implemented",z13 vesrlvg,"vector element shift right logical reg doubleword","not implemented",z13 -vrepif,"vector replicate immediate word","not implemented",z13 +vrepif,"vector replicate immediate word",implemented,z13 vfd,"vector fp divide","not implemented",z13 vesrlb,"vector element shift right logical mem byte","not implemented",z13 vavglg,"vector average logical double word","not implemented",z13 -vpksh,"vector pack saturate halfword","not implemented",z13 +vpksh,"vector pack saturate halfword",implemented,z13 veslv,"vector element shift left reg","not implemented",z13 vone,"vector set to ones","not implemented",z13 vsrl,"vector shift right logical","not implemented",z13 vcdg,"vector fp convert from fixed 64 bit","not implemented",z13 vmlhw,"vector multiply low halfword","not implemented",z13 vscbib,"vector subtract compute borrow indication byte","not implemented",z13 -vrepib,"vector replicate immediate byte","not implemented",z13 -vpk,"vector pack","not implemented",z13 +vrepib,"vector replicate immediate byte",implemented,z13 +vpk,"vector pack",implemented,z13 vmhh,"vector multiply high halfword","not implemented",z13 vfaezhs,"vector find any element equal","not implemented",z13 vaf,"vector add word","not implemented",z13 vmalh,"vector multiply and add logical high","not implemented",z13 -vgmg,"vector generate mask double word","not implemented",z13 +vgmg,"vector generate mask double word",implemented,z13 vstrczh,"vector string range compare halfword","not implemented",z13 vag,"vector add double word","not implemented",z13 -vllezf,"vector load logical word element and zero","not implemented",z13 +vllezf,"vector load logical word element and zero",implemented,z13 vistrbs,"vector isolate string byte","not implemented",z13 -vstm,"vector store multiple","not implemented",z13 +vstm,"vector store multiple",implemented,z13 vgfmh,"vector galois field multiply sum halfword","not implemented",z13 verllvf,"vector element rotate left logical reg word","not implemented",z13 vsra,"vector shift right arithmetic","not implemented",z13 vslb,"vector shift left by byte","not implemented",z13 vesravf,"vector element shift right arithmetic reg word","not implemented",z13 -vfcedbs,"vector fp compare equal","not implemented",z13 +vfcedbs,"vector fp compare equal long","not implemented",z13 vceqbs,"vector compare equal byte","not implemented",z13 vsbcbi,"vector subtract with borrow compute borrow indication","not implemented",z13 vmle,"vector multiply logical even","not implemented",z13 vfaezfs,"vector find any element equal","not implemented",z13 vsumg,"vector sum across doubleword","not implemented",z13 vfaeb,"vector find any element equal byte","not implemented",z13 -vleih,"vector load halfword element immediate","not implemented",z13 +vleih,"vector load halfword element immediate",implemented,z13 vmlob,"vector multiply logical odd byte","not implemented",z13 -vllezh,"vector load logical halfword element and zero","not implemented",z13 +vllezh,"vector load logical halfword element and zero",implemented,z13 vmalo,"vector multiply and add logical odd","not implemented",z13 vclzh,"vector count leading zeros halfword","not implemented",z13 vesravh,"vector element shift right arithmetic reg halfword","not implemented",z13 vceqfs,"vector compare equal word","not implemented",z13 vlp,"vector load positive","not implemented",z13 -wfmsdb,"vector fp multiply and subtract","not implemented",z13 +wfmsdb,"vector fp multiply and subtract long","not implemented",z13 vstrcbs,"vector string range compare byte","not implemented",z13 vaccg,"vector add compute carry doubleword","not implemented",z13 -wfsdb,"vector fp subtract","not implemented",z13 +wfsdb,"vector fp subtract long","not implemented",z13 vfee,"vector find element equal","not implemented",z13 vmxh,"vector maximum halfword","not implemented",z13 vtm,"vector test under mask","not implemented",z13 @@ -1251,38 +1251,38 @@ vesrl,"vector element shift right logical mem","not implemented",z13 vmah,"vector multiply and add high","not implemented",z13 vesrlvh,"vector element shift right logical reg halfword","not implemented",z13 vesrah,"vector element shift right arithmetic mem halfword","not implemented",z13 -vrepig,"vector replicate immediate double word","not implemented",z13 -wfddb,"vector fp divide","not implemented",z13 +vrepig,"vector replicate immediate double word",implemented,z13 +wfddb,"vector fp divide long","not implemented",z13 vmhf,"vector multiply high word","not implemented",z13 -vupllf,"vector unpack logical low word","not implemented",z13 +vupllf,"vector unpack logical low word",implemented,z13 veslf,"vector element shift left mem word","not implemented",z13 -wflpdb,"vector fp perform sign operation","not implemented",z13 +wflpdb,"vector fp perform sign operation long","not implemented",z13 vscbi,"vector subtract compute borrow indication","not implemented",z13 vmnlb,"vector minimum logical byte","not implemented",z13 veslh,"vector element shift left mem halfword","not implemented",z13 vfaebs,"vector find any element equal","not implemented",z13 -vleb,"vector load byte element","not implemented",z13 +vleb,"vector load byte element",implemented,z13 vfaezb,"vector find any element equal","not implemented",z13 -vlbb,"vector load to block boundary","not implemented",z13 -vflcdb,"vector fp perform sign operation","not implemented",z13 +vlbb,"vector load to block boundary",implemented,z13 +vflcdb,"vector fp perform sign operation long","not implemented",z13 vmlo,"vector multiply logical odd","not implemented",z13 -vlgvf,"vector load gr from vr word element","not implemented",z13 +vlgvf,"vector load gr from vr word element",implemented,z13 vavgf,"vector average word","not implemented",z13 veslvh,"vector element shift left reg halfword","not implemented",z13 vacch,"vector add compute carry halfword","not implemented",z13 vsumgh,"vector sum across doubleword - halfword","not implemented",z13 vmaeh,"vector multiply and add even halfword","not implemented",z13 vmnlh,"vector minimum logical halfword","not implemented",z13 -vstl,"vector store with length","not implemented",z13 -wfmadb,"vector fp multiply and add","not implemented",z13 +vstl,"vector store with length",implemented,z13 +wfmadb,"vector fp multiply and add long","not implemented",z13 vme,"vector multiply even","not implemented",z13 -wfmdb,"vector fp multiply","not implemented",z13 -wflcdb,"vector fp perform sign operation","not implemented",z13 -vreph,"vector replicate halfword","not implemented",z13 +wfmdb,"vector fp multiply long","not implemented",z13 +wflcdb,"vector fp perform sign operation long","not implemented",z13 +vreph,"vector replicate halfword",implemented,z13 vclgd,"vector fp convert to logical 64 bit","not implemented",z13 -vpkls,"vector pack logical saturate","not implemented",z13 +vpkls,"vector pack logical saturate",implemented,z13 vsf,"vector subtract word","not implemented",z13 -vflpdb,"vector fp perform sign operation","not implemented",z13 +vflpdb,"vector fp perform sign operation long","not implemented",z13 vesrlv,"vector element shift right logical reg","not implemented",z13 vpklsfs,"vector pack logical saturate word","not implemented",z13 vcdgb,"vector fp convert from fixed 64 bit","not implemented",z13 @@ -1295,36 +1295,36 @@ vfeneb,"vector find element not equal byte","not implemented",z13 vfene,"vector find element not equal","not implemented",z13 vfenezfs,"vector find element not equal word","not implemented",z13 vmal,"vector multiply and add low","not implemented",z13 -vfchdb,"vector fp compare high","not implemented",z13 +vfchdb,"vector fp compare high long","not implemented",z13 vfeezb,"vector find element equal byte","not implemented",z13 vfae,"vector find any element equal","not implemented",z13 -vfchdbs,"vector fp compare high","not implemented",z13 -vsceg,"vector scatter element 8 byte","not implemented",z13 +vfchdbs,"vector fp compare high long","not implemented long",z13 +vsceg,"vector scatter element 8 byte",implemented,z13 vfeezfs,"vector find element equal word","not implemented",z13 vsumgf,"vector sum across doubleword - word","not implemented",z13 vmnb,"vector minimum byte","not implemented",z13 -vlef,"vector load word element","not implemented",z13 +vlef,"vector load word element",implemented,z13 vceqgs,"vector compare equal double word","not implemented",z13 vech,"vector element compare half word","not implemented",z13 vctz,"vector count trailing zeros","not implemented",z13 vmloh,"vector multiply logical odd halfword","not implemented",z13 vaccc,"vector add with carry compute carry","not implemented",z13 vmale,"vector multiply and add logical even","not implemented",z13 -vsteh,"vector store halfword element","not implemented",z13 +vsteh,"vector store halfword element",implemented,z13 vceq,"vector compare equal","not implemented",z13 -vfchedbs,"vector fp compare high or equal","not implemented",z13 +vfchedbs,"vector fp compare high or equal long","not implemented",z13 vesl,"vector element shift left mem","not implemented",z13 vesrav,"vector element shift right arithmetic reg","not implemented",z13 vfma,"vector fp multiply and add","not implemented",z13 vmnlg,"vector minimum logical doubleword","not implemented",z13 vclz,"vector count leading zeros","not implemented",z13 -vmrlf,"vector merge low word","not implemented",z13 +vmrlf,"vector merge low word",implemented,z13 vistrh,"vector isolate string halfword","not implemented",z13 vmxlb,"vector maximum logical byte","not implemented",z13 vfs,"vector fp subtract","not implemented",z13 vfm,"vector fp multiply","not implemented",z13 -vll,"vector load with length","not implemented",z13 -vleig,"vector load double word element immediate","not implemented",z13 +vll,"vector load with length",implemented,z13 +vleig,"vector load double word element immediate",implemented,z13 vfaezbs,"vector find any element equal","not implemented",z13 veslvg,"vector element shift left reg doubleword","not implemented",z13 locfh,"load high on condition from memory","not implemented",z13 @@ -1342,7 +1342,7 @@ vfch,"vector fp compare high","not implemented",z13 lochi,"load halfword immediate on condition into 32 bit gpr","not implemented",z13 verllvh,"vector element rotate left logical reg halfword","not implemented",z13 cpdt,"convert from long dfp to packed","not implemented",z13 -vrepb,"vector replicate byte","not implemented",z13 +vrepb,"vector replicate byte","implemented",z13 ppno,"perform pseudorandom number operation","not implemented",z13 vfeef,"vector find element equal word","not implemented",z13 vac,"vector add with carry","not implemented",z13 @@ -1351,24 +1351,24 @@ vfi,"vector load fp integer","not implemented",z13 vistrfs,"vector isolate string word","not implemented",z13 vecf,"vector element compare word","not implemented",z13 vfeezbs,"vector find element equal byte","not implemented",z13 -wflndb,"vector fp perform sign operation","not implemented",z13 +wflndb,"vector fp perform sign operation long","not implemented",z13 vscbif,"vector subtract compute borrow indication word","not implemented",z13 vchhs,"vector compare high half word","not implemented",z13 vmlb,"vector multiply low byte","not implemented",z13 veslvf,"vector element shift left reg word","not implemented",z13 vfaefs,"vector find any element equal","not implemented",z13 -vlrep,"vector load and replicate","not implemented",z13 +vlrep,"vector load and replicate",implemented,z13 vaccf,"vector add compute carry word","not implemented",z13 -vpksf,"vector pack saturate word","not implemented",z13 +vpksf,"vector pack saturate word",implemented,z13 vavglf,"vector average logical word","not implemented",z13 vmef,"vector multiply even word","not implemented",z13 -vuplhh,"vector unpack logical high halfword","not implemented",z13 +vuplhh,"vector unpack logical high halfword",implemented,z13 vmxl,"vector maximum logical","not implemented",z13 vgfmah,"vector galois field multiply sum and accumulate halfword","not implemented",z13 vmalhf,"vector multiply and add logical high word","not implemented",z13 vsh,"vector subtract halfword","not implemented",z13 -vuplb,"vector unpack low byte","not implemented",z13 -vsegf,"vector sign extend word to double word","not implemented",z13 +vuplb,"vector unpack low byte",implemented,z13 +vsegf,"vector sign extend word to double word",implemented,z13 vmxlf,"vector maximum logical word","not implemented",z13 wcdlgb,"vector fp convert from logical 64 bit","not implemented",z13 vstrczb,"vector string range compare byte","not implemented",z13 @@ -1376,19 +1376,19 @@ vsldb,"vector shift left double by byte","not implemented",z13 vesrlh,"vector element shift right logical mem halfword","not implemented",z13 cdpt,"convert from packed to long dfp","not implemented",z13 vlcb,"vector load complement byte","not implemented",z13 -wfpsodb,"vector fp perform sign operation","not implemented",z13 +wfpsodb,"vector fp perform sign operation long","not implemented",z13 vsum,"vector sum across word","not implemented",z13 vfeehs,"vector find element equal halfword","not implemented",z13 vml,"vector multiply low","not implemented",z13 -vuphh,"vector unpack high halfword","not implemented",z13 +vuphh,"vector unpack high halfword",implemented,z13 vavglb,"vector average logical byte","not implemented",z13 vmlf,"vector multiply low word","not implemented",z13 -wledb,"vector fp load rounded","not implemented",z13 +wledb,"vector fp load rounded long to short","not implemented",z13 vstrcfs,"vector string range compare word","not implemented",z13 wcgdb,"vector fp convert to fixed 64 bit","not implemented",z13 vlph,"vector load positive halfword","not implemented",z13 vfenezf,"vector find element not equal word","not implemented",z13 -vseg,"vector sign extend to double word","not implemented",z13 +vseg,"vector sign extend to double word",implemented,z13 vcksm,"vector checksum","not implemented",z13 vsrlb,"vector shift right logical by byte","not implemented",z13 verimg,"vector element rotate and insert under mask doubleword","not implemented",z13 @@ -1396,16 +1396,16 @@ vesravg,"vector element shift right arithmetic reg doubleword","not implemented" vmlhh,"vector multiply logical high halfword","not implemented",z13 vfaezf,"vector find any element equal","not implemented",z13 vfenehs,"vector find element not equal halfword","not implemented",z13 -vlr,"vector register load","not implemented",z13 -vgbm,"vector generate byte mask","not implemented",z13 +vlr,"vector register load","implemented",z13 +vgbm,"vector generate byte mask","implemented",z13 vmnlf,"vector minimum logical word","not implemented",z13 -vlm,"vector load multiple","not implemented",z13 -vmrlb,"vector merge low byte","not implemented",z13 +vlm,"vector load multiple","implemented",z13 +vmrlb,"vector merge low byte","implemented",z13 vavglh,"vector average logical half word","not implemented",z13 wfkdb,"vector fp compare and signal scalar","not implemented",z13 veslb,"vector element shift left mem byte","not implemented",z13 wfchedb,"vector fp compare high or equal","not implemented",z13 -vllezg,"vector load logical double word element and zero","not implemented",z13 +vllezg,"vector load logical double word element and zero","implemented",z13 vmaob,"vector multiply and add odd byte","not implemented",z13 vmrhf,"vector merge high word","not implemented",z13 vchg,"vector compare high double word","not implemented",z13 @@ -1425,75 +1425,247 @@ vsl,"vector shift left","not implemented",z13 vfenezhs,"vector find element not equal halfword","not implemented",z13 vsg,"vector subtract doubleword","not implemented",z13 vclzf,"vector count leading zeros word","not implemented",z13 -wfcdb,"vector fp compare scalar","not implemented",z13 +wfcdb,"vector fp compare scalar long","not implemented",z13 vmaoh,"vector multiply and add odd halfword","not implemented",z13 vchgs,"vector compare high double word","not implemented",z13 vchlf,"vector compare high logical word","not implemented",z13 va,"vector add","not implemented",z13 -vmrlg,"vector merge low double word","not implemented",z13 +vmrlg,"vector merge low double word",implemented,z13 vlcg,"vector load complement doubleword","not implemented",z13 vceqf,"vector compare equal word","not implemented",z13 vacq,"vector add with carry quadword","not implemented",z13 vmaof,"vector multiply and add odd word","not implemented",z13 -vfadb,"vector fp add","not implemented",z13 +vfadb,"vector fp add long","not implemented",z13 vmlef,"vector multiply logical even word","not implemented",z13 wfc,"vector fp compare scalar","not implemented",z13 vmx,"vector maximum","not implemented",z13 vmlh,"vector multiply logical high","not implemented",z13 vmeb,"vector multiply even byte","not implemented",z13 -vfddb,"vector fp divide","not implemented",z13 +vfddb,"vector fp divide long","not implemented",z13 vpkshs,"vector pack saturate halfword","not implemented",z13 vpkf,"vector pack word","not implemented",z13 -vlrepg,"vector load and replicate double word elements","not implemented",z13 +vlrepg,"vector load and replicate double word elements",implemented,z13 vmaef,"vector multiply and add even word","not implemented",z13 vfeneh,"vector find element not equal halfword","not implemented",z13 vgfmaf,"vector galois field multiply sum and accumulate word","not implemented",z13 vctzg,"vector count trailing zeros doubleword","not implemented",z13 lzrg,"load and zero rightmost byte 64->64","not implemented",z13 vmof,"vector multiply odd word","not implemented",z13 -vfsqdb,"vector fp square root","not implemented",z13 -vlgvg,"vector load gr from vr double word element","not implemented",z13 +vfsqdb,"vector fp square root long","not implemented",z13 +vlgvg,"vector load gr from vr double word element",implemented,z13 verllf,"vector element rotate left logical mem word","not implemented",z13 verllg,"vector element rotate left logical mem doubleword","not implemented",z13 -vrepf,"vector replicate word","not implemented",z13 +vrepf,"vector replicate word",implemented,z13 vfeezhs,"vector find element equal halfword","not implemented",z13 -wfchdbs,"vector fp compare high","not implemented",z13 +wfchdbs,"vector fp compare high long","not implemented",z13 lochhi,"load halfword high immediate on condition","not implemented",z13 vmalhw,"vector multiply and add low halfword","not implemented",z13 vmlhb,"vector multiply logical high byte","not implemented",z13 vfeeh,"vector find element equal halfword","not implemented",z13 -vgm,"vector generate mask","not implemented",z13 +vgm,"vector generate mask",implemented,z13 vgfmab,"vector galois field multiply sum and accumulate byte","not implemented",z13 vmrhg,"vector merge high double word","not implemented",z13 veclg,"vector element compare logical double word","not implemented",z13 -vl,"vector memory load","not implemented",z13 +vl,"vector memory load",implemented,z13 vctzh,"vector count trailing zeros halfword","not implemented",z13 -vuplhf,"vector unpack logical high word","not implemented",z13 +vuplhf,"vector unpack logical high word",implemented,z13 verllvg,"vector element rotate left logical reg doubleword","not implemented",z13 -vupl,"vector unpack low","not implemented",z13 -vlgvb,"vector load gr from vr byte element","not implemented",z13 +vupl,"vector unpack low",implemented,z13 +vlgvb,"vector load gr from vr byte element",implemented,z13 vab,"vector add byte","not implemented",z13 vch,"vector compare high","not implemented",z13 veclf,"vector element compare logical word","not implemented",z13 -vgef,"vector gather element 4 byte elements","not implemented",z13 +vgef,"vector gather element 4 byte elements",implemented,z13 vscbiq,"vector subtract compute borrow indication quadword","not implemented",z13 cdgtr,"convert from fixed long dfp","not implemented",z13 vesrab,"vector element shift right arithmetic mem byte","not implemented",z13 vfsq,"vector fp square root","not implemented",z13 -vscef,"vector scatter element 4 byte","not implemented",z13 +vscef,"vector scatter element 4 byte",implemented,z13 vpkh,"vector pack halfword","not implemented",z13 vfa,"vector fp add","not implemented",z13 -vo,"vector or","not implemented",z13 +vo,"vector or",implemented,z13 verllb,"vector element rotate left logical mem byte","not implemented",z13 stocfh,"store high on condition","not implemented",z13 vchlbs,"vector compare high logical byte","not implemented",z13 -vuphf,"vector unpack high word","not implemented",z13 +vuphf,"vector unpack high word",implemented,z13 vacc,"vector add compute carry","not implemented",z13 vistrf,"vector isolate string word","not implemented",z13 vceqhs,"vector compare equal half word","not implemented",z13 -vfidb,"vector load fp integer","not implemented",z13 -vupllh,"vector unpack logical low halfword","not implemented",z13 +vfidb,"vector load fp integer long","not implemented",z13 +vupllh,"vector unpack logical low halfword",implemented,z13 vfce,"vector fp compare equal","not implemented",z13 vs,"vector subtract","not implemented",z13 vfeebs,"vector find element equal byte","not implemented",z13 -vlvgg,"vector load VR double word element from GR","not implemented",z13 +vlvgg,"vector load VR double word element from GR",implemented,z13 +vbperm,"vector bit permute","not implemented",arch12 +vllezlf,"vector load logical word element and zero - left aligned","not implemented","arch12" +vmsl,"vector multiply sum logical","not implemented","arch12" +vmslg,"vector multiply sum logical double word","not implemented","arch12" +vnx,"vector not exclusive or","not implemented","arch12" +vnn,"vector nand","not implemented","arch12" +voc,"vector or with complement","not implemented","arch12" +vpopctb,"vector population count byte","not implemented","arch12" +vpopcth,"vector population count halfword","not implemented","arch12" +vpopctf,"vector population count word","not implemented","arch12" +vpopctg,"vector population count double word","not implemented","arch12" +vfasb,"vector fp add short","not implemented","arch12" +wfasb,"scalar vector fp add scalar short","not implemented","arch12" +wfaxb,"scalar vector fp add scalar extended","not implemented","arch12" +wfcsb,"scalar vector fp compare scalar short","not implemented","arch12" +wfcxb,"scalar vector fp compare scalar extended","not implemented","arch12" +wfksb,"scalar vector fp compare and signal scalar short","not implemented","arch12" +wfkxb,"scalar vector fp compare and signal scalar extended","not implemented","arch12" +vfcesb,"vector fp compare equal short","not implemented","arch12" +vfcesbs,"vector fp compare equal short","not implemented","arch12" +wfcesb,"scalar vector fp compare equal scalar short","not implemented","arch12" +wfcesbs,"scalar fp compare equal scalar short","not implemented","arch12" +wfcexb,"scalar vector fp compare equal scalar extended","not implemented","arch12" +wfcexbs,"scalar vector fp compare equal scalar extended","not implemented","arch12" +vfkesb,"vector fp compare and signal equal short","not implemented","arch12" +vfkesbs,"vector fp compare and signal equal short","not implemented","arch12" +wfkesb,"scalar vector fp compare and signal equal scalar short","not implemented","arch12" +wfkesbs,"scalar fp compare and signal equal scalar short","not implemented","arch12" +vfkedb,"vector fp compare and signal equal long","not implemented","arch12" +vfkedbs,"vector fp compare and signal equal long","not implemented","arch12" +wfkedb,"vector fp compare and signal equal long","not implemented","arch12" +wfkedbs,"vector fp compare and signal equal long","not implemented","arch12" +wfkexb,"scalar vector fp compare and signal equal scalar extended","not implemented","arch12" +wfkexbs,"scalar vector fp compare and signal equal scalar extended","not implemented","arch12" +vfchsb,"vector fp compare high short","not implemented","arch12" +vfchsbs,"vector fp compare high short","not implemented","arch12" +wfchsb,"scalar vector fp compare high scalar short","not implemented","arch12" +wfchsbs,"scalar vector fp compare high scalar short","not implemented","arch12" +wfchxb,"scalar vector fp compare high scalar extended","not implemented","arch12" +wfchxbs,"scalar vector fp compare high scalar extended","not implemented","arch12" +vfkhsb,"vector fp compare and signal high short","not implemented","arch12" +vfkhsbs,"vector fp compare and signal high short","not implemented","arch12" +wfkhsb,"scalar vector fp compare and signal high scalar short","not implemented","arch12" +wfkhsbs,"scalar vector fp compare and signal high scalar short","not implemented","arch12" +vfkhdb,"vector fp compare and signal high long","not implemented","arch12" +vfkhdbs,"vector fp compare and signal high long","not implemented","arch12" +wfkhdb,"vector fp compare and signal high long","not implemented","arch12" +wfkhdbs,"vector fp compare and signal high long","not implemented","arch12" +wfkhxb,"scalar vector fp compare and signal high scalar extended","not implemented","arch12" +wfkhxbs,"scalar vector fp compare and signal high scalar extended","not implemented","arch12" +vfchesb,"vector fp compare high or equal short","not implemented","arch12" +vfchesbs,"vector fp compare high or equal short","not implemented","arch12" +wfchesb,"scalar vector fp compare high or equal scalar short","not implemented","arch12" +wfchesbs,"scalar vector fp compare high or equal scalar short","not implemented","arch12" +wfchexb,"scalar vector fp compare high or equal scalar extended","not implemented","arch12" +wfchexbs,"scalar vector fp compare high or equal scalar extended","not implemented","arch12" +vfkhesb,"vector fp compare and signal high or equal short","not implemented","arch12" +vfkhesbs,"vector fp compare and signal high or equal short","not implemented","arch12" +wfkhesb,"scalar vector fp compare and signal high or equal scalar short","arch12"implemented","arch12" +wfkhesbs,"scalar vector fp compare and signal high or equal scalar short","arch12"implemented","arch12" +vfkhedb,"vector fp compare and signal high or equal long","not implemented","arch12" +vfkhedbs,"vector fp compare and signal high or equal long","not implemented","arch12" +wfkhedb,"vector fp compare and signal high or equal long","not implemented","arch12" +wfkhedbs,"vector fp compare and signal high or equal long","not implemented","arch12" +wfkhexb,"scalar vector fp compare and signal high or equal scalar extended","arch12"implemented","arch12" +wfkhexbs,"scalar vector fp compare and signal high or equal scalar extended","arch12"implemented","arch12" +vfdsb,"vector fp divide short","not implemented","arch12" +wfdsb,"scalar vector fp divide scalar short","not implemented","arch12" +wfdxb,"scalar vector fp divide scalar extended","not implemented","arch12" +vfisb,"vector load fp integer short","not implemented","arch12" +wfisb,"scalar vector load fp integer scalar short","not implemented","arch12" +wfixb,"scalar vector load fp integer scalar extended","not implemented","arch12" +vfll,"vector fp load lengthened","not implemented","arch12" +vflls,"vector fp load lengthened","not implemented","arch12" +wflls,"scalar vector fp load lengthened short","not implemented","arch12" +wflld,"scalar vector fp load lengthened long","not implemented","arch12" +vflr,"vector fp load rounded","not implemented","arch12" +vflrd,"vector fp load rounded long","not implemented","arch12" +wflrd,"scalar vector fp load rounded long","not implemented","arch12" +wflrx,"scalar vector fp load rounded extended","not implemented","arch12" +vfmax,"vector fp maximum","not implemented","arch12" +vfmaxsb,"vector fp maximum short","not implemented","arch12" +vfmaxdb,"vector fp maximum long","not implemented","arch12" +wfmaxsb,"scalar fp maximum scalar short","not implemented","arch12" +wfmaxdb,"scalar fp maximum scalar long","not implemented","arch12" +wfmaxxb,"scalar fp maximum scalar extended","not implemented","arch12" +vfmin,"vector fp minimum","not implemented","arch12" +vfminsb,"vector fp minimum short","not implemented","arch12" +vfmindb,"vector fp minimum long","not implemented","arch12" +wfminsb,"scalar fp minimum scalar short","not implemented","arch12" +wfmindb,"scalar fp minimum scalar long","not implemented","arch12" +wfminxb,"scalar fp minimum scalar extended","not implemented","arch12" +vfmsb,"vector fp multiply short","not implemented","arch12" +wfmsb,"scalar vector fp multiply scalar short","not implemented","arch12" +wfmxb,"scalar vector fp multiply scalar extended","not implemented","arch12" +vfmasb,"vector fp multiply and add short","not implemented","arch12" +wfmasb,"scalar vector fp multiply and add scalar short","not implemented","arch12" +wfmaxb,"scalar vector fp multiply and add scalar extended","not implemented","arch12" +vfmssb,"vector fp multiply and subtract short","not implemented","arch12" +wfmssb,"scalar vector fp multiply and subtract scalar short","not implemented","arch12" +wfmsxb,"scalar vector fp multiply and subtract scalar extended","not implemented","arch12" +vfnma,"vector fp negative multiply and add","not implemented","arch12" +vfnmasb,"vector fp negative multiply and add short","not implemented","arch12" +wfnmasb,"scalar vector fp negative multiply and add scalar short","not implemented","arch12" +vfnmadb,"vector fp negative multiply and add long","not implemented","arch12" +wfnmadb,"scalar vector fp negative multiply and add scalar long","not implemented","arch12" +wfnmaxb,"scalar vector fp negative multiply and add scalar extended","not implemented","arch12" +vfnms,"vector fp negative multiply and subtract","not implemented","arch12" +vfnmssb,"vector fp negative multiply and subtract short","not implemented","arch12" +wfnmssb,"scalar vector fp negative multiply and subtract scalar short","arch12"implemented","arch12" +vfnmsdb,"vector fp negative multiply and subtract long","not implemented","arch12" +wfnmsdb,"scalar vector fp negative multiply and subtract scalar long","not implemented","arch12" +wfnmsxb,"scalar vector fp negative multiply and subtract scalar extended","arch12"implemented","arch12" +vfpsosb,"vector fp perform sign operation short","not implemented","arch12" +wfpsosb,"scalar vector fp perform sign operation scalar short","not implemented","arch12" +vflcsb,"vector fp perform sign operation short","not implemented","arch12" +wflcsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12" +vflnsb,"vector fp perform sign operation short","not implemented","arch12" +wflnsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12" +vflpsb,"vector fp perform sign operation short","not implemented","arch12" +wflpsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12" +wfpsoxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12" +wflcxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12" +wflnxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12" +wflpxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12" +vfsqsb,"vector fp square root short","not implemented","arch12" +wfsqsb,"scalar vector fp square root scalar short","not implemented","arch12" +wfsqxb,"scalar vector fp square root scalar extended","not implemented","arch12" +vfssb,"vector fp subtract short","not implemented","arch12" +wfssb,"scalar vector fp subtract scalar short","not implemented","arch12" +wfsxb,"scalar vector fp subtract scalar extended","not implemented","arch12" +vftcisb,"vector fp test data class immediate short","not implemented","arch12" +wftcisb,"scalar vector fp test data class immediate scalar short","not implemented","arch12" +wftcixb,"scalar vector fp test data class immediate scalar extended","not implemented","arch12" +agh,"add halfword to 64 bit value","not implemented","arch12" +bic,"branch indirect on condition","not implemented","arch12" +bi,"unconditional indirect branch","not implemented","arch12" +mgrk,"multiply 64x64reg -> 128","not implemented","arch12" +mg,"multiply 64x64mem -> 128","not implemented","arch12" +mgh,"multiply halfword 64x16mem -> 64","not implemented","arch12" +msrkc,"multiply single 32x32 -> 32","not implemented","arch12" +msgrkc,"multiply single 64x64 -> 64","not implemented","arch12" +msc,"multiply single 32x32mem -> 32","not implemented","arch12" +msgc,"multiply single 64x64mem -> 64","not implemented","arch12" +sgh,"subtract halfword from 64 bit value","not implemented","arch12" +vlrlr,"vector load rightmost with length","not implemented","arch12" +vlrl,"vector load rightmost with immediate length","not implemented","arch12" +vstrlr,"vector store rightmost with length","not implemented","arch12" +vstrl,"vector store rightmost with immediate length","not implemented","arch12" +vap,"vector add decimal","not implemented","arch12" +vcp,"vector compare decimal","not implemented","arch12" +vcvb,"vector convert to binary 32 bit","not implemented","arch12" +vcvbg,"vector convert to binary 64 bit","not implemented","arch12" +vcvd,"vector convert to decimal 32 bit","not implemented","arch12" +vcvdg,"vector convert to decimal 64 bit","not implemented","arch12" +vdp,"vector divide decimal","not implemented","arch12" +vlip,"vector load immediate decimal","not implemented","arch12" +vmp,"vector multiply decimal","not implemented","arch12" +vmsp,"vector multiply and shift decimal","not implemented","arch12" +vpkz,"vector pack zoned","not implemented","arch12" +vpsop,"vector perform sign operation decimal","not implemented","arch12" +vrp,"vector remainder decimal","not implemented","arch12" +vsdp,"vector shift and divide decimal","not implemented","arch12" +vsrp,"vector shift and round decimal","not implemented","arch12" +vsp,"vector subtract decimal","not implemented","arch12" +vtp,"vector test decimal","not implemented","arch12" +vupkz,"vector unpack zoned","not implemented","arch12" +lgg,"load guarded 64 bit","not implemented","arch12" +llgfsg,"load logical and shift guarded 64 bit","not implemented","arch12" +lgsc,"load guarded storage controls","not implemented","arch12" +stgsc,"store guarded storage controls","not implemented","arch12" +kma,"cipher message with galois counter mode","not implemented","arch12" diff --git a/memcheck/mc_machine.c b/memcheck/mc_machine.c index d05125a9a8..5ed101fcac 100644 --- a/memcheck/mc_machine.c +++ b/memcheck/mc_machine.c @@ -783,14 +783,20 @@ static Int get_otrack_shadow_offset_wrk ( Int offset, Int szB ) /* fprs are accessed 4 or 8 byte at once. Again, we track that change for - the full register */ - if ((sz == 8 || sz == 4) && o >= GOF(f0) && o <= GOF(f15)+8-sz) - return GOF(f0) + ((o-GOF(f0)) & -8) ; + the full register + NOTE: FPRs are mapped to first double word of VRs[0-15] */ + if ((sz == 8 || sz == 4) && o >= GOF(v0) && o <= GOF(v15)+8-sz) + return GOF(v0) + ((o-GOF(v0)) & -8) ; /* access registers are accessed 4 bytes at once */ if (sz == 4 && o >= GOF(a0) && o <= GOF(a15)) return o; + /* no matter what byte(s) we change, we have changed the full 16 byte value + and need to track this change for the whole register */ + if (o >= GOF(v0) && sz <= 16 && o <= (GOF(v31) + 16 - sz)) + return GOF(v0) + ((o-GOF(v0)) & -16) ; + /* we access the guest counter either fully or one of the 4byte words */ if (o == GOF(counter) && (sz == 8 || sz ==4)) return o; diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c index cbdb65bae9..ae7e472d13 100644 --- a/memcheck/mc_translate.c +++ b/memcheck/mc_translate.c @@ -3108,6 +3108,22 @@ IRAtom* expr2vbits_Triop ( MCEnv* mce, complainIfUndefined(mce, atom2, NULL); return assignNew('V', mce, Ity_I64, triop(op, vatom1, atom2, vatom3)); + case Iop_SetElem8x16: + case Iop_SetElem16x8: + case Iop_SetElem32x4: + case Iop_SetElem64x2: + complainIfUndefined(mce, atom2, NULL); + return assignNew('V', mce, Ity_V128, triop(op, vatom1, atom2, vatom3)); + + case Iop_Perm8x16x2: + /* (V128, V128, V128) -> V128 */ + complainIfUndefined(mce, atom3, NULL); + return mkUifUV128( + mce, + assignNew('V', mce, Ity_V128, triop(op, vatom1, vatom2, atom3)), + mkPCast8x16(mce, vatom3) + ); + /* Vector FP with rounding mode as the first arg */ case Iop_Add64Fx2: case Iop_Sub64Fx2: diff --git a/memcheck/tests/vbit-test/irops.c b/memcheck/tests/vbit-test/irops.c index 7c5fa14951..5eea89bfc2 100644 --- a/memcheck/tests/vbit-test/irops.c +++ b/memcheck/tests/vbit-test/irops.c @@ -1001,6 +1001,10 @@ static irop_t irops[] = { { DEFOP(Iop_GetElem16x8, UNDEF_UNKNOWN), }, { DEFOP(Iop_GetElem32x4, UNDEF_UNKNOWN), }, { DEFOP(Iop_GetElem64x2, UNDEF_UNKNOWN), }, + { DEFOP(Iop_SetElem8x16, UNDEF_UNKNOWN), }, + { DEFOP(Iop_SetElem16x8, UNDEF_UNKNOWN), }, + { DEFOP(Iop_SetElem32x4, UNDEF_UNKNOWN), }, + { DEFOP(Iop_SetElem64x2, UNDEF_UNKNOWN), }, { DEFOP(Iop_Dup8x16, UNDEF_UNKNOWN), }, { DEFOP(Iop_Dup16x8, UNDEF_UNKNOWN), }, { DEFOP(Iop_Dup32x4, UNDEF_UNKNOWN), }, @@ -1014,6 +1018,7 @@ static irop_t irops[] = { { DEFOP(Iop_Reverse1sIn8_x16, UNDEF_UNKNOWN), }, { DEFOP(Iop_Perm8x16, UNDEF_UNKNOWN), }, { DEFOP(Iop_Perm32x4, UNDEF_UNKNOWN), }, + { DEFOP(Iop_Perm8x16x2, UNDEF_UNKNOWN), }, { DEFOP(Iop_GetMSBs8x16, UNDEF_UNKNOWN), }, { DEFOP(Iop_RecipEst32Ux4, UNDEF_UNKNOWN), }, { DEFOP(Iop_RSqrtEst32Ux4, UNDEF_UNKNOWN), }, diff --git a/none/tests/s390x/Makefile.am b/none/tests/s390x/Makefile.am index ff10dc5fb0..781c421a09 100644 --- a/none/tests/s390x/Makefile.am +++ b/none/tests/s390x/Makefile.am @@ -18,7 +18,7 @@ INSN_TESTS = clc clcle cvb cvd icm lpr tcxb lam_stam xc mvst add sub mul \ spechelper-cr spechelper-clr \ spechelper-ltr spechelper-or \ spechelper-icm-1 spechelper-icm-2 spechelper-tmll \ - spechelper-tm laa + spechelper-tm laa vector if BUILD_DFP_TESTS INSN_TESTS += dfp-1 dfp-2 dfp-3 dfp-4 dfptest dfpext dfpconv srnmt pfpo endif @@ -65,3 +65,4 @@ cu24_1_CFLAGS = $(AM_CFLAGS) -DM3=1 fixbr_CFLAGS = $(AM_CFLAGS) @FLAG_MLONG_DOUBLE_128@ fpext_CFLAGS = $(AM_CFLAGS) @FLAG_MLONG_DOUBLE_128@ ex_clone_LDADD = -lpthread +vector_CFLAGS = $(AM_CFLAGS) -march=z13 diff --git a/none/tests/s390x/stfle.c b/none/tests/s390x/stfle.c index 6c8007bf9e..af884a14cc 100644 --- a/none/tests/s390x/stfle.c +++ b/none/tests/s390x/stfle.c @@ -1,7 +1,7 @@ #include /* Number of double words needed to store all facility bits. */ -#define S390_NUM_FACILITY_DW 2 +#define S390_NUM_FACILITY_DW 3 unsigned long long stfle(unsigned long dw, unsigned bit_to_test) @@ -20,6 +20,8 @@ unsigned long long stfle(unsigned long dw, unsigned bit_to_test) match = (hoststfle[0] & (1ULL << (63 - bit_to_test))); else if (bit_to_test < 128) match = (hoststfle[1] & (1ULL << (63 - bit_to_test))); + else if (bit_to_test < 192) + match = (hoststfle[2] & (1ULL << (63 - bit_to_test))); else printf("code needs to be updated\n"); @@ -45,7 +47,7 @@ int main() /* Test #3: Tell STFLE to only write 1 DW of facility bits. Expected condition code should be 3 because this test is run on those machines only - that need 2 do double words to store facility bits. */ + that need 3 do double words to store facility bits. */ dw = 1; if ((stfle(dw, 1)) && stfle(dw, 2)) printf("The z/Architecture architectural mode is installed and active\n"); diff --git a/none/tests/s390x/stfle.stdout.exp b/none/tests/s390x/stfle.stdout.exp index a4e971673c..2cf903c789 100644 --- a/none/tests/s390x/stfle.stdout.exp +++ b/none/tests/s390x/stfle.stdout.exp @@ -1,10 +1,10 @@ -the value of cc is 0 and #double words is 2 -the value of cc is 0 and #double words is 2 +the value of cc is 0 and #double words is 3 +the value of cc is 0 and #double words is 3 The z/Architecture architectural mode is installed and active -the value of cc is 0 and #double words is 2 +the value of cc is 0 and #double words is 3 STFLE facility is installed -the value of cc is 3 and #double words is 2 -the value of cc is 3 and #double words is 2 +the value of cc is 3 and #double words is 3 +the value of cc is 3 and #double words is 3 The z/Architecture architectural mode is installed and active -the value of cc is 3 and #double words is 2 +the value of cc is 3 and #double words is 3 No MSA facility available diff --git a/none/tests/s390x/stfle.vgtest b/none/tests/s390x/stfle.vgtest index 76644b54a3..458793df37 100644 --- a/none/tests/s390x/stfle.vgtest +++ b/none/tests/s390x/stfle.vgtest @@ -1,2 +1,2 @@ prog:stfle -prereq: ../../../tests/s390x_features s390x-stfle z196 +prereq: ../../../tests/s390x_features s390x-stfle z196: diff --git a/none/tests/s390x/vector.c b/none/tests/s390x/vector.c new file mode 100644 index 0000000000..90671b0362 --- /dev/null +++ b/none/tests/s390x/vector.c @@ -0,0 +1,244 @@ +#include "vector.h" + + +s390_test_generate(vl_vst, "vl %%v5, %[v_arg1]") +s390_test_generate(vlr, "vlr %%v5, %%v1") + +s390_test_generate(vlrep, "vlrepg %%v1, %[m_arg1]\n" \ + "vlrepf %%v2, %[m_arg2]\n" \ + "vlreph %%v3, %[m_arg3]\n" \ + "vlrepb %%v5, %[m_arg1]") + +s390_test_generate(vle, "vleb %%v5, %[m_arg1], 14\n" \ + "vleh %%v5, %[m_arg2], 6\n" \ + "vlef %%v5, %[m_arg3], 2\n" \ + "vleg %%v5, %[m_arg1], 0") + +s390_test_generate(vlei_pos, "vleib %%v5, 0x091a, 14\n" \ + "vleih %%v5, 0x1bbb, 6\n" \ + "vleif %%v5, 0x1ccc, 2\n" \ + "vleig %%v5, 0x1ddd, 0") + +s390_test_generate(vlei_neg, "vleib %%v5, -0x091a, 14\n" \ + "vleih %%v5, -0x1bbb, 6\n" \ + "vleif %%v5, -0x1ccc, 2\n" \ + "vleig %%v5, -0x1ddd, 0") + +s390_test_generate(vlvg, "vlvgb %[r_arg1], %%v1, 12(0)\n" \ + "vlvgh %[r_arg2], %%v2, 6(0)\n" \ + "vlvgf %[r_arg3], %%v3, 2(0)\n" \ + "vlvgg %[r_arg1], %%v5, 1(0)") + +s390_test_generate(vgbm, "vgbm %%v1, 0xf00f \n" \ + "vzero %%v2 \n" \ + "vone %%v5") + +s390_test_generate(vgm, "vgmb %%v1, 4, 6 \n" \ + "vgmh %%v2, 2, 14 \n" \ + "vgmf %%v3, 3, 23 \n" + "vgmg %%v3, 1, 55") + +s390_test_generate(vllez, "vllezb %%v1, %[m_arg1]\n" \ + "vllezh %%v2, %[m_arg2]\n" \ + "vllezf %%v3, %[m_arg3]\n" + "vllezg %%v5, %[m_arg1]") + +s390_test_generate(vgef, "vzero %%v1\n" \ + "vgef %%v5, 16(%%v1, %[r_memory_pool]), 2 \n") +s390_test_generate(vgeg, "vzero %%v1\n" \ + "vgeg %%v5, 32(%%v1, %[r_memory_pool]), 1 \n") + +s390_test_generate(vlm_vstm, "vlm %%v1, %%v3, %[m_memory_pool]\n" \ + "vstm %%v1, %%v3, %[m_memory_pool]\n") + +s390_test_generate(vlvgp, "vlvgp %%v1, %[r_arg1], %[r_arg2]") + +s390_test_generate(vlgv, "vlgvb %[r_arg1], %%v1, 12(0)\n" \ + "vlgvh %[r_arg2], %%v2, 6(0)\n" \ + "vlgvf %[r_arg3], %%v3, 2(0)\n" + "vlgvg %[r_arg1], %%v5, 1(0)") + +s390_test_generate(vmrhb, "vmrhb %%v5, %%v1, %%v2") +s390_test_generate(vmrhh, "vmrhh %%v5, %%v1, %%v2") +s390_test_generate(vmrhf, "vmrhf %%v5, %%v1, %%v2") +s390_test_generate(vmrhg, "vmrhg %%v5, %%v1, %%v2") + +s390_test_generate(vmrlb, "vmrlb %%v5, %%v1, %%v2") +s390_test_generate(vmrlh, "vmrlh %%v5, %%v1, %%v2") +s390_test_generate(vmrlf, "vmrlf %%v5, %%v1, %%v2") +s390_test_generate(vmrlg, "vmrlg %%v5, %%v1, %%v2") + +s390_test_generate(vpkh, "vpkh %%v5, %%v1, %%v2") +s390_test_generate(vpkf, "vpkf %%v5, %%v1, %%v2") +s390_test_generate(vpkg, "vpkg %%v5, %%v1, %%v2") +s390_test_generate(vpksh, "vpksh %%v5, %%v1, %%v2") +s390_test_generate(vpksf, "vpksf %%v5, %%v1, %%v2") +s390_test_generate(vpksg, "vpksg %%v5, %%v1, %%v2") +s390_test_generate(vpklsh, "vpklsh %%v5, %%v1, %%v2") +s390_test_generate(vpklsf, "vpklsf %%v5, %%v1, %%v2") +s390_test_generate(vpklsg, "vpklsg %%v5, %%v1, %%v2") + +s390_test_generate(vpkshs, "vpkshs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") +s390_test_generate(vpksfs, "vpksfs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") +s390_test_generate(vpksgs, "vpksgs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") +s390_test_generate(vpklshs, "vpklshs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") +s390_test_generate(vpklsfs, "vpklsfs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") +s390_test_generate(vpklsgs, "vpklsgs %%v5, %%v1, %%v2\n" \ + "ipm %[r_result]\n" \ + "srl %[r_result], 28") + +s390_test_generate(vperm, "vperm %%v5, %%v1, %%v2, %%v3") + +s390_test_generate(vpdi0, "vpdi %%v5, %%v1, %%v2, 0") +s390_test_generate(vpdi1, "vpdi %%v5, %%v1, %%v2, 1") +s390_test_generate(vpdi4, "vpdi %%v5, %%v1, %%v2, 4") +s390_test_generate(vpdi5, "vpdi %%v5, %%v1, %%v2, 5") + +s390_test_generate(vscef, "vzero %%v1\n" \ + "vscef %%v5, 0(%%v1, %[r_memory_pool]), 1") +s390_test_generate(vsceg, "vzero %%v1\n" \ + "vsceg %%v5, 16(%%v1, %[r_memory_pool]), 1") + +s390_test_generate(vsegb, "vsegb %%v5, %%v1") +s390_test_generate(vsegh, "vsegh %%v5, %%v1") +s390_test_generate(vsegf, "vsegf %%v5, %%v1") + +s390_test_generate(vste, "vsteb %%v1, %[m_arg1], 4\n" \ + "vsteh %%v1, %[m_arg2], 3\n" \ + "vstef %%v1, %[m_arg3], 2\n" \ + "vsteg %%v1, %[m_arg1], 1\n") + +s390_test_generate(vuph, "vuphb %%v2, %%v1\n" \ + "vuphh %%v3, %%v1\n" \ + "vuphf %%v5, %%v1") +s390_test_generate(vuplh, "vuplhb %%v2, %%v1\n" \ + "vuplhh %%v3, %%v1\n" \ + "vuplhf %%v5, %%v1") +s390_test_generate(vupl, "vuplb %%v2, %%v1\n" \ + "vuplhw %%v3, %%v1\n" \ + "vuplf %%v5, %%v1") +s390_test_generate(vupll, "vupllb %%v2, %%v1\n" \ + "vupllh %%v3, %%v1\n" \ + "vupllf %%v5, %%v1") + +s390_test_generate(vrepb, "vrepb %%v5, %%v1, 1") +s390_test_generate(vreph, "vreph %%v5, %%v1, 1") +s390_test_generate(vrepf, "vrepf %%v5, %%v1, 1") +s390_test_generate(vrepg, "vrepg %%v5, %%v1, 1") + +s390_test_generate(vrepib, "vrepib %%v5, -0x0fee") +s390_test_generate(vrepih, "vrepih %%v5, -0x0fee") +s390_test_generate(vrepif, "vrepif %%v5, -0x0fee") +s390_test_generate(vrepig, "vrepig %%v5, -0x0fee") + +s390_test_generate(vsel, "vsel %%v5, %%v1, %%v2, %%v3") +s390_test_generate(vll_vstl, "vll %%v5, %[r_arg1], %[v_arg1]\n" \ + "vstl %%v5, %[r_arg1], %[v_arg2]\n" \ + "vl %%v2, %[v_arg2]") + +s390_test_generate(vlbb, "vlbb %%v5, 60(%[r_memory_pool]), 0") + +int main() { + size_t iteration = 0; + randomize_memory_pool(); + + /* Some of insn depend only on immediate arguments, which are known at compile time. + There is no need to run them more than once. We use test_once() for them. + */ + + /* Theese insn are used in every test. Test them first */ + test(vl_vst); + test_once(vgbm); + + test(vlr); + test(vlrep); + + test(vle); + + test(vlei_pos); + test(vlei_neg); + + test(vlgv); + test(vgm); + + test(vllez); + test(vlvgp); + test(vlvg); + + test(vmrhb); + test(vmrhh); + test(vmrhf); + test(vmrhg); + + test(vmrlb); + test(vmrlh); + test(vmrlf); + test(vmrlg); + + test(vpkh); + test(vpkf); + test(vpkg); + + test(vperm); + test(vpdi0); + test(vpdi1); + test(vpdi4); + test(vpdi5); + + test(vsegb); + test(vsegh); + test(vsegf); + + test(vste); + + test(vuph); + test(vuplh); + test(vupl); + test(vupll); + + test(vrepb); + test(vreph); + test(vrepf); + test(vrepg); + + test_once(vrepib); + test_once(vrepih); + test_once(vrepif); + test_once(vrepig); + + test(vpksh); + test(vpkshs); + test(vpksf); + test(vpksfs); + test(vpksg); + test(vpksgs); + + test(vpklsh); + test(vpklshs); + test(vpklsf); + test(vpklsfs); + test(vpklsg); + test(vpklsgs); + + test(vsel); + test(vll_vstl); + + test(vlbb, (randomize_memory_pool())); + test(vlm_vstm, (randomize_memory_pool())); + test(vgef, (randomize_memory_pool())); + test(vgeg, (randomize_memory_pool())); + test(vscef, (randomize_memory_pool())); + test(vsceg, (randomize_memory_pool())); + + return 0; +} diff --git a/none/tests/s390x/vector.h b/none/tests/s390x/vector.h new file mode 100644 index 0000000000..a6538b43fd --- /dev/null +++ b/none/tests/s390x/vector.h @@ -0,0 +1,173 @@ +#ifndef S390_TEST_VECTOR_H +#define S390_TEST_VECTOR_H + +#include "stdbool.h" +#include "stdint.h" +#include "stdio.h" +#include "string.h" + +/* How many times should every test be executed? */ +#define S390_TEST_COUNT 10 + +/* Test the instruction exactly one time. */ +#define test_once(insn) test_##insn() + +/* Test the instruction exactly S390_TEST_COUNT times. + "..." arguments specifies code which must be executed after each tests + */ +#define test(insn, ...) \ + for(iteration = 0; iteration < S390_TEST_COUNT; iteration++) \ + { test_##insn(); \ + __VA_ARGS__; \ + } + +#ifdef __GNUC__ +/* GCC complains about __int128 with -pedantic */ +/* Hope that we will have int128_t in C standard someday. */ +#pragma GCC diagnostic ignored "-Wpedantic" +#endif + +typedef union { + uint8_t u8[16]; + int8_t s8[16]; + + uint16_t u16[8]; + int16_t s16[8]; + + uint32_t u32[4]; + int32_t s32[4]; + + uint64_t u64[2]; + int64_t s64[2]; + + unsigned __int128 u128[1]; + __int128 s128[1]; +} V128; + +void print_hex(const V128 value) { + printf("%016lx | %016lx\n", value.u64[0], value.u64[1]); +} + +void print_uint64_t(const uint64_t value) { + printf("%016lx\n", value); +} + +uint8_t random_element ( void ) +{ + static uint32_t seed = 80021; + seed = 1103515245 * seed + 12345; + return (seed >> 17) & 0xFF; +} + +void random_V128 (V128 *block) +{ + size_t i; + for(i = 0; i < 16; i++) + { + block->u8[i] = random_element(); + } +} + +uint64_t random_uint64_t() +{ + uint64_t result = 0ULL; + uint8_t *ptr = (uint8_t *) &result; + size_t i; + for(i = 0; i < 8; i++) + { + ptr[i] = random_element(); + } + + return result; +} + +/* Memory pool with some random data. Used for some instruction which need + an address to some memory chunk. + Pool should be large enough for all insn that use it. + (64 bytes and aligning are needed by VLBB insn) + + Content of this pool must be updated every iteration but not from test to test. +*/ +uint8_t random_memory_pool[64] __attribute__ ((aligned (64))); +void randomize_memory_pool() +{ + size_t i; + for(i = 0; i < sizeof(random_memory_pool) / sizeof(random_memory_pool[0]); i++) + { + random_memory_pool[i] = random_element(); + } +} + +/* Define a test for input. Takes up theese arguments: + insn -- instruction name + asm_string -- line (or multiple lines) with asm mnemonics for instruction + + The folowing registers layout expected: + ("r" for register form and m for memory form) + v1 -- vector arg1 + v2 -- vector arg2 + v3 -- vector arg3 + v5 -- vector result + [{r,m}_arg1] -- integer arg1 + [{r,m}_arg2] -- integer arg2 + [{r,m}_arg3] -- integer arg3 + [{r,m}_result] -- integer result + [{r,m}_memory_pool] -- address of random memory pool. Usefull for some instructions + +*/ +#define s390_test_generate(insn, asm_string) \ +static void test_##insn() \ +{ \ + V128 v_result = { .u64 = {0ULL, 0ULL} }; \ + V128 v_arg1; \ + V128 v_arg2; \ + V128 v_arg3; \ + uint64_t r_arg1 = random_uint64_t(); \ + uint64_t r_arg2 = random_uint64_t(); \ + uint64_t r_arg3 = random_uint64_t(); \ + uint64_t r_result = 0ULL; \ + \ + random_V128(&v_arg1); \ + random_V128(&v_arg2); \ + random_V128(&v_arg3); \ + \ + __asm__ volatile( \ + "vl %%v1, %[v_arg1]\n" \ + "vl %%v2, %[v_arg2]\n" \ + "vl %%v3, %[v_arg3]\n" \ + "vone %%v5\n" \ + asm_string "\n"\ + "vst %%v5, %[v_result]\n" \ + "vst %%v1, %[v_arg1]\n" \ + "vst %%v2, %[v_arg2]\n" \ + "vst %%v3, %[v_arg3]\n" \ + : [v_result] "=m" (v_result), \ + [m_result] "=m" (r_result), \ + [r_result] "+d" (r_result), \ + [r_arg1] "+d" (r_arg1), \ + [r_arg2] "+d" (r_arg2), \ + [r_arg3] "+d" (r_arg3) \ + : [v_arg1] "m" (v_arg1), \ + [v_arg2] "m" (v_arg2), \ + [v_arg3] "m" (v_arg3), \ + [m_arg1] "m" (r_arg1), \ + [m_arg2] "m" (r_arg2), \ + [m_arg3] "m" (r_arg3), \ + [r_memory_pool] "r" (random_memory_pool), \ + [m_memory_pool] "m" (random_memory_pool) \ + : "memory", "cc", \ + "r1", "r2", "r3", "r5", \ + "v1", "v2", "v3", "v5"); \ + \ + printf("insn %s:\n", #insn); \ + printf(" v_arg1 = "); print_hex(v_arg1); \ + printf(" v_arg2 = "); print_hex(v_arg2); \ + printf(" v_arg3 = "); print_hex(v_arg3); \ + printf(" v_result = "); print_hex(v_result); \ + printf(" r_arg1 = "); print_uint64_t(r_arg1); \ + printf(" r_arg2 = "); print_uint64_t(r_arg2); \ + printf(" r_arg3 = "); print_uint64_t(r_arg3); \ + printf(" r_result = "); print_uint64_t(r_result); \ +} + +#endif diff --git a/none/tests/s390x/vector.stderr.exp b/none/tests/s390x/vector.stderr.exp new file mode 100644 index 0000000000..139597f9cb --- /dev/null +++ b/none/tests/s390x/vector.stderr.exp @@ -0,0 +1,2 @@ + + diff --git a/none/tests/s390x/vector.stdout.exp b/none/tests/s390x/vector.stdout.exp new file mode 100644 index 0000000000..f4e3fcb56d --- /dev/null +++ b/none/tests/s390x/vector.stdout.exp @@ -0,0 +1,5355 @@ +insn vl_vst: + v_arg1 = 6b3e625d19775d06 | e540bc6839c44b4a + v_arg2 = 36ed3550df9899d8 | 979b83b70eb840d7 + v_arg3 = 856c13b8709950cb | 8315cab0121ab056 + v_result = 6b3e625d19775d06 | e540bc6839c44b4a + r_arg1 = 382dccdbc2829139 + r_arg2 = fd673a5c2148a319 + r_arg3 = 179e655064dc2a84 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 3d6603cf39008e39 | 979569ee6d5cbcd8 + v_arg2 = 966cf73d98a42d54 | e87fc9cb92bba120 + v_arg3 = 40ef72e29bf3afcf | 172ebcce16c982d1 + v_result = 3d6603cf39008e39 | 979569ee6d5cbcd8 + r_arg1 = db93c0f8294addf9 + r_arg2 = 5df605a7d127a7d3 + r_arg3 = 1f195c53c95bf85f + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 069b4435908d7b40 | 10985cc9e2b9c255 + v_arg2 = b2683bbf21432695 | cf9d2353bceded84 + v_arg3 = 11188dbe47a5f281 | a9c6e8f73d48698d + v_result = 069b4435908d7b40 | 10985cc9e2b9c255 + r_arg1 = 6eb865944fab9d36 + r_arg2 = 8adae4bb36b59768 + r_arg3 = b76e2305226ee0f4 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 64ff133b4dd65eb9 | 4208cb757c0f3e0a + v_arg2 = 91fe3de1d5e7ca54 | 2a3193a81cbd8ee9 + v_arg3 = 6efeebb0fcde6db7 | 02921c5fc5455f0a + v_result = 64ff133b4dd65eb9 | 4208cb757c0f3e0a + r_arg1 = 0b635974bf639901 + r_arg2 = b3397de854eca15b + r_arg3 = e4e02305a70c35f0 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = f83fd8ce0401495f | e5f1216d47c3a621 + v_arg2 = c1582e6bf6f3b5e9 | 1e41d09eeb4d0896 + v_arg3 = d0498c5ca63d4863 | b4985c390f9bf2ac + v_result = f83fd8ce0401495f | e5f1216d47c3a621 + r_arg1 = 92a7705a2d5b324d + r_arg2 = 9045684013b74ac8 + r_arg3 = f3807c7237dd6262 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 2b582ed8725fe2c9 | 376fbfe93425c861 + v_arg2 = 1870f7a36a759b08 | d466094bc52ab4ec + v_arg3 = 77eca2665a8c4256 | d3eaa2736713076f + v_result = 2b582ed8725fe2c9 | 376fbfe93425c861 + r_arg1 = 6aa872c5336e1ba8 + r_arg2 = 1cfdf65003ac2d2e + r_arg3 = 35ecc3a818f7a873 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = eb54a60037342630 | bc68bf9dda3685ee + v_arg2 = 6fcaf40c7feb0484 | 3d83a1c16d0e812c + v_arg3 = 2aea572c0f856fff | bc679d7dba2599b3 + v_result = eb54a60037342630 | bc68bf9dda3685ee + r_arg1 = 3f55e1b30e241fff + r_arg2 = 59f1ebe418d2ba28 + r_arg3 = c411c4ffb49ddd2d + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 6b0c886e9a6f2728 | ff55ac7f3661970c + v_arg2 = 663cba29a8010f0e | cf8af1ce8da3b236 + v_arg3 = f4148b8c668ffa2b | d27f73015eb678f0 + v_result = 6b0c886e9a6f2728 | ff55ac7f3661970c + r_arg1 = c22db0626572df5c + r_arg2 = 0ffd44c56f5bf82e + r_arg3 = 3de842925d012f37 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = e7e79284496dce65 | 50f94b806c444cdc + v_arg2 = 23a9d13a3e4f30f5 | 473c0ac17342a347 + v_arg3 = e9c893a36480e4c5 | 3dee80abcfda0b81 + v_result = e7e79284496dce65 | 50f94b806c444cdc + r_arg1 = 6dfc0d09037a92aa + r_arg2 = 8d0bf37d096a4357 + r_arg3 = 843bb2f40b01df96 + r_result = 0000000000000000 +insn vl_vst: + v_arg1 = 5e98b7a518b89a76 | 8526565084674a1c + v_arg2 = 13c07bfc401df2e6 | 65e87126d6ae84b9 + v_arg3 = dfb3fc8a335bc495 | aa7e15e16c920f5d + v_result = 5e98b7a518b89a76 | 8526565084674a1c + r_arg1 = 3c9d19a2984fc36e + r_arg2 = 68d59e108ccd1018 + r_arg3 = 845f04fa19ed086d + r_result = 0000000000000000 +insn vgbm: + v_arg1 = ffffffff00000000 | 00000000ffffffff + v_arg2 = 0000000000000000 | 0000000000000000 + v_arg3 = 368e461ae5128604 | 0ec83a8a3e8e56d7 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 76b9aca27db1178e + r_arg2 = 389f65c305c2a505 + r_arg3 = edfa5b770c3e56bc + r_result = 0000000000000000 +insn vlr: + v_arg1 = 9c56b0049bcf0832 | 122de4537ebadd80 + v_arg2 = 1b359083443f73f0 | 40ad0d2c61ae8842 + v_arg3 = 91e3aaa730432cd5 | 63f36dc9b2ea8964 + v_result = 9c56b0049bcf0832 | 122de4537ebadd80 + r_arg1 = 638612bd6ecb050c + r_arg2 = 5fff99d7a9b4e28d + r_arg3 = f5bdd1fa4c5ecf22 + r_result = 0000000000000000 +insn vlr: + v_arg1 = 02123abc75575714 | 74b2685cb1632af8 + v_arg2 = 28bac9f9424875f9 | 5ee85cdbb3b2fa66 + v_arg3 = 9ac7d6c734fe91ec | 6a7262c15bf3e754 + v_result = 02123abc75575714 | 74b2685cb1632af8 + r_arg1 = 1387d1a54efb9dcb + r_arg2 = c298864d8ffdfbc1 + r_arg3 = 182a3590ea668e9d + r_result = 0000000000000000 +insn vlr: + v_arg1 = 2082c9f33727a0bb | 4f96da5fe8beae08 + v_arg2 = d5b8af0426ba1f6b | 68e2ab9751e67b83 + v_arg3 = c3a0ac0b317c2109 | 68c8c152b2e20596 + v_result = 2082c9f33727a0bb | 4f96da5fe8beae08 + r_arg1 = 1e5061cbe7894247 + r_arg2 = 8ed82ba378a53c0c + r_arg3 = d84ecd8759d98447 + r_result = 0000000000000000 +insn vlr: + v_arg1 = 1422a140b2f1924e | 57330304e93afcc5 + v_arg2 = 2c244e196b83aa0a | 7ef00f632f75abca + v_arg3 = 00df06c352e7a38c | ea46ebd9d69e8d77 + v_result = 1422a140b2f1924e | 57330304e93afcc5 + r_arg1 = 5f42f21ba76d705f + r_arg2 = f5c0fd948820c4fb + r_arg3 = 7e861427356d361a + r_result = 0000000000000000 +insn vlr: + v_arg1 = 4338b8b95c14ef51 | 466d1f2de1b67b62 + v_arg2 = fc44eca9b6c0e377 | 477491fe277a7c0a + v_arg3 = 8fc576bd6618f031 | 81cab6f34d7dff61 + v_result = 4338b8b95c14ef51 | 466d1f2de1b67b62 + r_arg1 = b84a2bc2650c780e + r_arg2 = ef9ca8da0c134bf5 + r_arg3 = d83c7d7a00c182ac + r_result = 0000000000000000 +insn vlr: + v_arg1 = 169d7db2145d5069 | 9c7aa2bc253b2bf0 + v_arg2 = 9c69c1e38f79f1f0 | af9ff1a7b6bafb70 + v_arg3 = b121ff06a252bad4 | 87802d39c101739f + v_result = 169d7db2145d5069 | 9c7aa2bc253b2bf0 + r_arg1 = d2a4e6eb1afa3f2c + r_arg2 = fac5cfee320edd02 + r_arg3 = faa92f04e0265bf2 + r_result = 0000000000000000 +insn vlr: + v_arg1 = bf73927edcc8e315 | 609cf752ecc5611e + v_arg2 = a9b4be7727660d13 | a72f64dac36c0847 + v_arg3 = 6f0fdda5610a462d | d9a35203c59e5516 + v_result = bf73927edcc8e315 | 609cf752ecc5611e + r_arg1 = da9df67ca9b70430 + r_arg2 = db64c7c5d4519d87 + r_arg3 = fd93c88963598800 + r_result = 0000000000000000 +insn vlr: + v_arg1 = f2ee922b9e3e2c74 | dde43c0d17fa87f9 + v_arg2 = c4d4485011ac499a | e930571059f419b8 + v_arg3 = 56b94365e4a23294 | 9c3cdc288e72280c + v_result = f2ee922b9e3e2c74 | dde43c0d17fa87f9 + r_arg1 = 464be1db997517f0 + r_arg2 = 5b3160932e898407 + r_arg3 = c40f1bcd3c4569c5 + r_result = 0000000000000000 +insn vlr: + v_arg1 = ac0fcc49e957c804 | 67f00848ebf0ddad + v_arg2 = 55c5fa58099e4a1e | b2bd2a8168a2fb89 + v_arg3 = 3c18198b132731bc | f9e0fabbba0a45e4 + v_result = ac0fcc49e957c804 | 67f00848ebf0ddad + r_arg1 = 8e55a6aed6cfa35d + r_arg2 = 0b2e9d8aa49320e2 + r_arg3 = b23ff24e04c4b3d2 + r_result = 0000000000000000 +insn vlr: + v_arg1 = f06206a2b119265f | 14ac275ed2ea3c41 + v_arg2 = 4c916736b17f0fd7 | 86bff6e3897691e1 + v_arg3 = f9b2ba9a3b19cb7a | e0750ece0d229ade + v_result = f06206a2b119265f | 14ac275ed2ea3c41 + r_arg1 = f4b079957492654a + r_arg2 = 016f789a7e375517 + r_arg3 = 7514cd0afa5e3012 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 3e5e83f16d777325 | 3e5e83f16d777325 + v_arg2 = 99d5a03199d5a031 | 99d5a03199d5a031 + v_arg3 = c00cc00cc00cc00c | c00cc00cc00cc00c + v_result = 3e3e3e3e3e3e3e3e | 3e3e3e3e3e3e3e3e + r_arg1 = 3e5e83f16d777325 + r_arg2 = 99d5a031aced2004 + r_arg3 = c00ca23ec4078191 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 7730a49f5ee4f7ba | 7730a49f5ee4f7ba + v_arg2 = 36cc3bfc36cc3bfc | 36cc3bfc36cc3bfc + v_arg3 = 09f309f309f309f3 | 09f309f309f309f3 + v_result = 7777777777777777 | 7777777777777777 + r_arg1 = 7730a49f5ee4f7ba + r_arg2 = 36cc3bfc83995024 + r_arg3 = 09f39c232ce3dc39 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = b28431bb4fb1f2f6 | b28431bb4fb1f2f6 + v_arg2 = ff13a4a3ff13a4a3 | ff13a4a3ff13a4a3 + v_arg3 = 4fa44fa44fa44fa4 | 4fa44fa44fa44fa4 + v_result = b2b2b2b2b2b2b2b2 | b2b2b2b2b2b2b2b2 + r_arg1 = b28431bb4fb1f2f6 + r_arg2 = ff13a4a37e514ccf + r_arg3 = 4fa4dcb2e504cf8f + r_result = 0000000000000000 +insn vlrep: + v_arg1 = c706b66068e0faa0 | c706b66068e0faa0 + v_arg2 = a3732e8fa3732e8f | a3732e8fa3732e8f + v_arg3 = d7c8d7c8d7c8d7c8 | d7c8d7c8d7c8d7c8 + v_result = c7c7c7c7c7c7c7c7 | c7c7c7c7c7c7c7c7 + r_arg1 = c706b66068e0faa0 + r_arg2 = a3732e8fff15d0fc + r_arg3 = d7c83b5f4429fb78 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 1571b565bd62fd20 | 1571b565bd62fd20 + v_arg2 = 1685e0a51685e0a5 | 1685e0a51685e0a5 + v_arg3 = eb94eb94eb94eb94 | eb94eb94eb94eb94 + v_result = 1515151515151515 | 1515151515151515 + r_arg1 = 1571b565bd62fd20 + r_arg2 = 1685e0a50b94b000 + r_arg3 = eb9407e0077fdaf9 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 3e4d662103d8fc3b | 3e4d662103d8fc3b + v_arg2 = 526f380b526f380b | 526f380b526f380b + v_arg3 = 9a8d9a8d9a8d9a8d | 9a8d9a8d9a8d9a8d + v_result = 3e3e3e3e3e3e3e3e | 3e3e3e3e3e3e3e3e + r_arg1 = 3e4d662103d8fc3b + r_arg2 = 526f380b12ec944e + r_arg3 = 9a8dc2e712637af1 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = efb17627594ed1d4 | efb17627594ed1d4 + v_arg2 = 17a6e9e117a6e9e1 | 17a6e9e117a6e9e1 + v_arg3 = 7c467c467c467c46 | 7c467c467c467c46 + v_result = efefefefefefefef | efefefefefefefef + r_arg1 = efb17627594ed1d4 + r_arg2 = 17a6e9e1a669bb38 + r_arg3 = 7c46e7e22e1d41df + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 9602c9080200ebab | 9602c9080200ebab + v_arg2 = acac9d07acac9d07 | acac9d07acac9d07 + v_arg3 = 6b1f6b1f6b1f6b1f | 6b1f6b1f6b1f6b1f + v_result = 9696969696969696 | 9696969696969696 + r_arg1 = 9602c9080200ebab + r_arg2 = acac9d073f43b9ac + r_arg3 = 6b1fa5c0c9a4a7a1 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = 2ab1381626170d20 | 2ab1381626170d20 + v_arg2 = 9cd2b4dc9cd2b4dc | 9cd2b4dc9cd2b4dc + v_arg3 = 4b074b074b074b07 | 4b074b074b074b07 + v_result = 2a2a2a2a2a2a2a2a | 2a2a2a2a2a2a2a2a + r_arg1 = 2ab1381626170d20 + r_arg2 = 9cd2b4dcfe633af6 + r_arg3 = 4b07a2adb95f0031 + r_result = 0000000000000000 +insn vlrep: + v_arg1 = e8ff541e946b13ef | e8ff541e946b13ef + v_arg2 = 7bf503fb7bf503fb | 7bf503fb7bf503fb + v_arg3 = c439c439c439c439 | c439c439c439c439 + v_result = e8e8e8e8e8e8e8e8 | e8e8e8e8e8e8e8e8 + r_arg1 = e8ff541e946b13ef + r_arg2 = 7bf503fb681ebd83 + r_arg3 = c439bad3fae03069 + r_result = 0000000000000000 +insn vle: + v_arg1 = 6ce30772cb393162 | 50a3967f672fd7de + v_arg2 = 2a8d07f3c58484af | 3c382b7f925fed2c + v_arg3 = 4e4ac99461d51c4c | 6d365e1e6aaa3164 + v_result = 11ba222c8341adf4 | 0301be1a9f4311ff + r_arg1 = 11ba222c8341adf4 + r_arg2 = 9f4397ff27f65a9a + r_arg3 = 0301be1a6caa75bf + r_result = 0000000000000000 +insn vle: + v_arg1 = 13af05a6f8ae09e3 | 55572620ab0f011d + v_arg2 = b4781cf689a66f00 | 28275d8857f70c71 + v_arg3 = ef4917b37e37a9b5 | 4d4fed92cb05eb2f + v_result = ad00dd4a4d0d23e6 | 7e7737e7e8f6adff + r_arg1 = ad00dd4a4d0d23e6 + r_arg2 = e8f6713fcd5f7d23 + r_arg3 = 7e7737e796eb2108 + r_result = 0000000000000000 +insn vle: + v_arg1 = c2a43fbb996badf8 | 5ab7d2b735faacdb + v_arg2 = 9d0003212fe3c3b9 | f8d3aec91ec973c6 + v_arg3 = e01226b801bd1353 | 8decf5f9fdfe8e92 + v_result = 4bfab83f3330101f | ad4121df79164bff + r_arg1 = 4bfab83f3330101f + r_arg2 = 791648929176a863 + r_arg3 = ad4121df66415e38 + r_result = 0000000000000000 +insn vle: + v_arg1 = 8fd5aea1f63a049f | 0cb41a414677a106 + v_arg2 = e7b48241aa40f176 | c427e99c4f17fa34 + v_arg3 = 0dae884c8baa585e | b0f58e099896fdb3 + v_result = bfa09a521cba2751 | d254b0a47d3abfff + r_arg1 = bfa09a521cba2751 + r_arg2 = 7d3a4a0a10ca36bc + r_arg3 = d254b0a4ef78e91e + r_result = 0000000000000000 +insn vle: + v_arg1 = d62202c6fe940736 | 1dcbf3fa837c83a7 + v_arg2 = 5c6f941e16f101b0 | 2b1ecf193e12cd61 + v_arg3 = aaf5839564ec8b69 | 40e145b69a3af1d5 + v_result = e47ae1075727f251 | b2b20f96e447e4ff + r_arg1 = e47ae1075727f251 + r_arg2 = e447dbbb0e161470 + r_arg3 = b2b20f962a48d72a + r_result = 0000000000000000 +insn vle: + v_arg1 = f9fa62d6085d8837 | 05ca8a1db62c87a8 + v_arg2 = 471d2d4175174e7c | 1080dad7e19a2f53 + v_arg3 = f44fd6f739e19329 | 8f75def22584b818 + v_result = 585c20e055248ece | 5a2b1c91232e58ff + r_arg1 = 585c20e055248ece + r_arg2 = 232e55743303865e + r_arg3 = 5a2b1c91b71a542a + r_result = 0000000000000000 +insn vle: + v_arg1 = 2118287b8ea8ecfc | c28bffa291993a8f + v_arg2 = 3f76f2af6e814c51 | 5da4f5a995fd392d + v_arg3 = e87075d3dd14f12e | 7181126e42fef63c + v_result = 4328e11c714a7119 | dc1f2eb4f8af43ff + r_arg1 = 4328e11c714a7119 + r_arg2 = f8afc782cfe9e9c2 + r_arg3 = dc1f2eb499c26007 + r_result = 0000000000000000 +insn vle: + v_arg1 = fc48a71df177f17a | 99b62bfd6b813f43 + v_arg2 = ddc001ae0d6e42c1 | c32e4661ddb699f0 + v_arg3 = 0e1a494a080077a7 | 04a85256a2e1685d + v_result = 118e6479a8e024de | 0f39d016241b11ff + r_arg1 = 118e6479a8e024de + r_arg2 = 241bb873978d6bf7 + r_arg3 = 0f39d016fe45918b + r_result = 0000000000000000 +insn vle: + v_arg1 = 7d21e6a1397a6a08 | d3825be401140fc5 + v_arg2 = 818fb07e8648113d | 79d1e58f232e543a + v_arg3 = 31ddf1f91cca1221 | 6918831858d09cb7 + v_result = 33ce5ff5619c0ae7 | 54348491300c33ff + r_arg1 = 33ce5ff5619c0ae7 + r_arg2 = 300ce2d066e3d537 + r_arg3 = 54348491f593d41d + r_result = 0000000000000000 +insn vle: + v_arg1 = a0cb622cd2ceff19 | 8273130837abb8f7 + v_arg2 = 1287461ff268ecd4 | f90da242767c8408 + v_arg3 = 25d984bddb098247 | 894cc01ca1a1bb62 + v_result = e373bc87276118de | 4c98827b2a2ee3ff + r_arg1 = e373bc87276118de + r_arg2 = 2a2ef7e0fecb4258 + r_arg3 = 4c98827b374c2c82 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 24bad0e050bfeefc | 3a1ccdd9d5909f57 + v_arg2 = bc17c41010d81ef3 | c7f0c4c44a271b76 + v_arg3 = 80784e6f32811da1 | d1d01c8b9c134115 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = de185fe96b019c0b + r_arg2 = 65f95f6ac5d7e68f + r_arg3 = a37c7666df7e729c + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 5070d99c2d85cda1 | d8ddb8444bbc3ec3 + v_arg2 = b03fa00d060ac825 | 2bd8c5603ce29f7c + v_arg3 = 62378fa7f2e29157 | f6fc5e0b1397c0e6 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = 2925de5044faf711 + r_arg2 = 3d73f8728902c930 + r_arg3 = c94446e63264142d + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = af3dddbf87084756 | 3fa47a776e92e735 + v_arg2 = e74a85ce1fa4a0d3 | f22d171ecc4eedb2 + v_arg3 = 2f5d407c928c9fef | b3b5c47f310aa106 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = cd9147302f3c63b3 + r_arg2 = d1f0d5f93c798a6a + r_arg3 = b462ca495926d794 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = d400b1e4e39fdb84 | 16aeee9b39a78086 + v_arg2 = e09214ce8b37b404 | 312ae28322baf70b + v_arg3 = 4fc1cd41f04de109 | 8732c1cb4a77e288 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = 9aa0defbcfe0ae93 + r_arg2 = c7d401c0b9551d0e + r_arg3 = a018935f229e968d + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 18e661a5edcba075 | 8c46e7988e7d462e + v_arg2 = 5e41a7002202251c | 0294c554cbe5869c + v_arg3 = f587dc480d1f8629 | 78b4bf8c97d8da1a + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = e8a4dde1aef0fdf0 + r_arg2 = 0c4e3a057e5d8d47 + r_arg3 = d034a532c41001f3 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 5729f05b35ff0410 | 1584ecd3f3428b01 + v_arg2 = 2c0d099a22b2ed9f | 467f915379b9f955 + v_arg3 = d6e206a1d5ed116c | d34bdee2f8d5f1c9 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = 52bf3391fb248b66 + r_arg2 = 921eb74371c7bb62 + r_arg3 = 4bd13ece98f05f80 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = b7d113dbf45a8899 | 2b0dfbf1569378f2 + v_arg2 = d9fa40cced239bee | 620f1200c70f04c5 + v_arg3 = eed299dad54e1e4f | ea96b329b08269bf + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = 7b9e47f54aa268b1 + r_arg2 = 114ee3f49cf61e86 + r_arg3 = a01a8df9e19f4d89 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 6275fb3ac66a8774 | 0fd84793ca3eccd2 + v_arg2 = 7d1b4488cd1e1207 | 0333c757f27072d9 + v_arg3 = 3fe55dbf03471d6e | d5820bba2d231907 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = ca3fb2f858bc3c68 + r_arg2 = c8fb2051f13b817b + r_arg3 = a3097cfa862c7dc6 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = 47f909886fe9ede2 | 86e6fb1a47fa9c10 + v_arg2 = 7350c53bb01b4e47 | db6aa597a2d1e59c + v_arg3 = 92f84d1a7a0c1541 | 3209a6adbeea2d46 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = 2eaa0942c6b401c5 + r_arg2 = 390c860e0797c966 + r_arg3 = 2e236755d3157807 + r_result = 0000000000000000 +insn vlei_pos: + v_arg1 = dd4f9797978201c2 | 9c07f5646f2f1179 + v_arg2 = 1d07e991ed001f2a | 6181d8f89f5591f7 + v_arg3 = 34f659733cbd63df | e5f3fd995cb6e782 + v_result = 0000000000001ddd | 00001ccc1bbb1aff + r_arg1 = daba91f9d97acd5a + r_arg2 = f1f8a121dc76ad89 + r_arg3 = e13ce38b3c065dfe + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = e139b6b38d8c1c4f | 659a8c8c44b32df8 + v_arg2 = a3fd0c33fddfed09 | 955282729d0d0570 + v_arg3 = bb962bcfef2c7abe | da96fe5163d562de + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 0ad40980416b86db + r_arg2 = 3e83377c91747d06 + r_arg3 = e33879dd1a98a1fb + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = 1404eb6a08cc6fe7 | b84c4aadf38a8756 + v_arg2 = b5fd808b43ba73d9 | bb857b7bf2bae3ed + v_arg3 = c020e073a194a16f | bf98cba656c14a5a + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = bdac643acf12acda + r_arg2 = f77f00cd321add9c + r_arg3 = a0c669086c12cda9 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = fe4df244e235c1c0 | f2d6b39d8ea40bfa + v_arg2 = 459e4b7dc64184f1 | 1c500fc75b88a471 + v_arg3 = a327cba18462b865 | cbab7f2a9ee5a695 + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 7a068d473ee91485 + r_arg2 = 398e6d436ca08767 + r_arg3 = 89256809982944d4 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = afbf7c8adcaa30b3 | bac2fdb4caa1bca9 + v_arg2 = 4f08ec2df290cac3 | c939c409bbd355dd + v_arg3 = 4a4f3658b3eef4ae | 7a4ee9ea4c588f8e + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 0c712244ec18a768 + r_arg2 = 24dd624a55ab0ca2 + r_arg3 = d7e262d929c2fb26 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = 79d1f1025eb9ecf4 | b826d785c58e7345 + v_arg2 = 91ae17bf5bf582a0 | 58d213b0dde45daf + v_arg3 = e2072117ec419fb7 | 4f914f32d39ff75d + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 460c3a0d9e332830 + r_arg2 = a3e9fc4c280f9467 + r_arg3 = 49963a318fad3fe3 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = b78b2eaf356000d6 | 5c6623a3c3a79e8f + v_arg2 = 541375117aa74277 | a57a2aa92db335c4 + v_arg3 = 9d4e019955cfd90b | 91d12d4cd06d64fd + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = c143207d40feec64 + r_arg2 = 223d4d71078e9a6c + r_arg3 = e2ab8545e36b73b3 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = 8a40499553cb098a | 9ef4bc5cec1602e7 + v_arg2 = 228965816f8eb495 | 9221b12283a52f18 + v_arg3 = 73718399383d5b12 | 0f76f43fc365b205 + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 9992162ba32ba02c + r_arg2 = 56301c5fb895b2c6 + r_arg3 = ad17548ba1e8d057 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = 975449719313fde0 | b912318010b2790a + v_arg2 = 8eecbeacbe005865 | c8038243d94e3183 + v_arg3 = e3c9478ec71c2fd5 | ddbacc93d3d5d568 + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 3440132e3d19070d + r_arg2 = f9aaa6f9690443a9 + r_arg3 = 7a1ee8746c402471 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = cbf6ef8372fee603 | f08d891964bfb5d2 + v_arg2 = f0698b2c12804730 | 756b70f5102f777d + v_arg3 = b080a66edaaa79b7 | 1564530a8f7b943b + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = fc2386d8ed95baaa + r_arg2 = 8cde60226de54e24 + r_arg3 = 9e127b30cd7c9440 + r_result = 0000000000000000 +insn vlei_neg: + v_arg1 = 18e57147d8c4a53f | 4982fe3244b3fcf9 + v_arg2 = 263cce57fe80ebdd | 0d70029eb07855d9 + v_arg3 = a44b6e6dac96323b | 97875c66a843506d + v_result = ffffffffffffe223 | ffffe334e445e6ff + r_arg1 = 2061117db69be783 + r_arg2 = 140fb379fc3226e8 + r_arg3 = b715fe6df5545a60 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 362d3936cec6b0bd | 551bc293efedead4 + v_arg2 = 556b3f05b71fc8b0 | 0aba36e2a6c5f38c + v_arg3 = 5030a1bda2bbe8c4 | ca47b229b805bc8f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 000000000000a6c5 + r_arg3 = 00000000ca47b229 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 63eaab894558d544 | e751bd824f7e331a + v_arg2 = a68f0b49dcea370d | ac3c3f6204e41066 + v_arg3 = cb413a4f04e2804f | 5a93d34efe4aa38d + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 00000000000004e4 + r_arg3 = 000000005a93d34e + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 2302ddf4d677f5f8 | d8ab4e82afe45f9d + v_arg2 = 0a8b96352f9d2734 | baf9477fc58bc0d6 + v_arg3 = 6f5de890c283f539 | f8eab6132006a671 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 000000000000c58b + r_arg3 = 00000000f8eab613 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 01ee5e6d7d92ca1e | cafc061682c88d0e + v_arg2 = f751399a5ae2db05 | 3fc22e1787252ea9 + v_arg3 = a0f4d12b328317fe | 1e1886b2e95efc26 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 0000000000008725 + r_arg3 = 000000001e1886b2 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 4d71f0e55e44a3d4 | e328717e23c531bd + v_arg2 = 2aa205c4ab0fafbd | 4ef549454f845bca + v_arg3 = 86c251cbcdf64df6 | c8f865220a623131 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 0000000000004f84 + r_arg3 = 00000000c8f86522 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = dd5d4e0c811623dc | 8eddcd779023d755 + v_arg2 = 63cd7e40d9ebd3b6 | c03f242349afde01 + v_arg3 = ce91b9d8f6dd5418 | 3d332ad9d9d2e778 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 00000000000049af + r_arg3 = 000000003d332ad9 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = cd53e710963f0650 | 3e5cd1fd2f96dea2 + v_arg2 = 2d6e6298be680e29 | f15942898694a3b7 + v_arg3 = 6dfa1138b3e7feba | c4fe248b15dc98fe + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 0000000000008694 + r_arg3 = 00000000c4fe248b + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 4082a25db267dc6d | 2c31690b8a033d4d + v_arg2 = 943061141b697dee | 88cdd9cebdd5acaf + v_arg3 = 5d24d70f7233f44d | 70dfd5eaa0db53a3 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 000000000000bdd5 + r_arg3 = 0000000070dfd5ea + r_result = 0000000000000000 +insn vlgv: + v_arg1 = 1d66995c105ecc4c | 14f57558143a429c + v_arg2 = ed8ae27a577c5238 | 2cb097850b7ed4cd + v_arg3 = 5f82be7ec60a7524 | d667b96644187be7 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 0000000000000b7e + r_arg3 = 00000000d667b966 + r_result = 0000000000000000 +insn vlgv: + v_arg1 = d389de37d1e853a3 | fc128d1be2bb4f36 + v_arg2 = 9283c5cd409f975c | 50686040b3cb87d1 + v_arg3 = b897716627a8162d | d2f8fdee6f8a8da6 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ffffffffffffffff + r_arg2 = 000000000000b3cb + r_arg3 = 00000000d2f8fdee + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = eb3dc30504754bd0 + r_arg2 = 57aaf518c3d8885e + r_arg3 = 30cdfd8fb35310e1 + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 6078e143b2b67531 + r_arg2 = 8c9f3141195bd737 + r_arg3 = 9a0247bf4985cf0c + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 46e0da2d64e00a85 + r_arg2 = e82b1682e4cf13a5 + r_arg3 = 08669e504bbdf32a + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 619e06bbf1322d31 + r_arg2 = 8714419fb2f103b9 + r_arg3 = ac1ba792bff7a9bd + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 7d6a3220965ad7b8 + r_arg2 = 486f885a36ac0865 + r_arg3 = 3a55fa978b1d76e3 + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 2846628fb632967a + r_arg2 = 925eb23109dbd439 + r_arg3 = af15e7eb41c5f41a + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 79468ff69c854f76 + r_arg2 = 10d240256b033420 + r_arg3 = 0ee7345cd5f595fc + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = cc4a6ac434cafc0a + r_arg2 = 76492770ff1bc827 + r_arg3 = 1eaaddb261e15e03 + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 84c118a5d6e66fb1 + r_arg2 = 3a8f944c9347c635 + r_arg3 = 2e47d376e8abae45 + r_result = 0000000000000000 +insn vgm: + v_arg1 = 0e0e0e0e0e0e0e0e | 0e0e0e0e0e0e0e0e + v_arg2 = 3ffe3ffe3ffe3ffe | 3ffe3ffe3ffe3ffe + v_arg3 = 7fffffffffffff00 | 7fffffffffffff00 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = c867f543fced0ec3 + r_arg2 = 5b7fa8b1d696bcd2 + r_arg3 = d277bfae1120f637 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 0000000000000047 | 0000000000000000 + v_arg2 = 0000000000001ec2 | 0000000000000000 + v_arg3 = 00000000a580bd9e | 0000000000000000 + v_result = 4706520608df9537 | 0000000000000000 + r_arg1 = 4706520608df9537 + r_arg2 = 1ec23a1620ca4be3 + r_arg3 = a580bd9ee8807f6c + r_result = 0000000000000000 +insn vllez: + v_arg1 = 00000000000000f5 | 0000000000000000 + v_arg2 = 000000000000cd8d | 0000000000000000 + v_arg3 = 0000000005f72187 | 0000000000000000 + v_result = f53737d4006dd862 | 0000000000000000 + r_arg1 = f53737d4006dd862 + r_arg2 = cd8d982e2f10ed6a + r_arg3 = 05f72187a2352755 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 00000000000000cc | 0000000000000000 + v_arg2 = 0000000000007765 | 0000000000000000 + v_arg3 = 00000000da7e366a | 0000000000000000 + v_result = cc2021d052b57fb8 | 0000000000000000 + r_arg1 = cc2021d052b57fb8 + r_arg2 = 776547abe5c2b049 + r_arg3 = da7e366a56992402 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 000000000000008c | 0000000000000000 + v_arg2 = 000000000000b4dd | 0000000000000000 + v_arg3 = 000000005086fac4 | 0000000000000000 + v_result = 8c36c51d9000c988 | 0000000000000000 + r_arg1 = 8c36c51d9000c988 + r_arg2 = b4ddbefd0b2bfafe + r_arg3 = 5086fac4c5b4c1de + r_result = 0000000000000000 +insn vllez: + v_arg1 = 000000000000007c | 0000000000000000 + v_arg2 = 0000000000005e55 | 0000000000000000 + v_arg3 = 00000000980ce452 | 0000000000000000 + v_result = 7cfbcd9b358a4ac3 | 0000000000000000 + r_arg1 = 7cfbcd9b358a4ac3 + r_arg2 = 5e55301311424467 + r_arg3 = 980ce45213fa1d75 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 0000000000000027 | 0000000000000000 + v_arg2 = 00000000000059bc | 0000000000000000 + v_arg3 = 00000000ac5f9fcd | 0000000000000000 + v_result = 27c097a75f39aeb4 | 0000000000000000 + r_arg1 = 27c097a75f39aeb4 + r_arg2 = 59bc4017cd6bdf7f + r_arg3 = ac5f9fcd8b0ff030 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 0000000000000021 | 0000000000000000 + v_arg2 = 0000000000004d4d | 0000000000000000 + v_arg3 = 0000000009d7cdad | 0000000000000000 + v_result = 2162f9dd936274c8 | 0000000000000000 + r_arg1 = 2162f9dd936274c8 + r_arg2 = 4d4dcb34383cb21d + r_arg3 = 09d7cdad60854516 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 00000000000000c0 | 0000000000000000 + v_arg2 = 0000000000006754 | 0000000000000000 + v_arg3 = 00000000739dc6e9 | 0000000000000000 + v_result = c00f00d87d8ab446 | 0000000000000000 + r_arg1 = c00f00d87d8ab446 + r_arg2 = 6754a2513535faba + r_arg3 = 739dc6e9689b418c + r_result = 0000000000000000 +insn vllez: + v_arg1 = 00000000000000e4 | 0000000000000000 + v_arg2 = 0000000000001ce9 | 0000000000000000 + v_arg3 = 00000000b56856b4 | 0000000000000000 + v_result = e401acefae21da16 | 0000000000000000 + r_arg1 = e401acefae21da16 + r_arg2 = 1ce94dd64a85092a + r_arg3 = b56856b4e0fedc14 + r_result = 0000000000000000 +insn vllez: + v_arg1 = 00000000000000b0 | 0000000000000000 + v_arg2 = 000000000000e7b2 | 0000000000000000 + v_arg3 = 000000005f3c8340 | 0000000000000000 + v_result = b040b6f95d47697d | 0000000000000000 + r_arg1 = b040b6f95d47697d + r_arg2 = e7b2ca6565ca0961 + r_arg3 = 5f3c83402b8aa310 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = 4f634c08288ab9dd | 07a44da199cfb72e + v_arg2 = 45d3b155068ab4c0 | d0e1cb64b5143d39 + v_arg3 = 178fad5f95d86dbd | 4d5b3a7d86204d6a + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 4f634c08288ab9dd + r_arg2 = 07a44da199cfb72e + r_arg3 = 872c457d93097d7e + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = b14fd030d0a5ba78 | 42c1fee9df4f2802 + v_arg2 = 87096ba97fb48a34 | a947fa647965d36c + v_arg3 = 427af7a4e16a24e6 | bd1c6dcc2fec0cce + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = b14fd030d0a5ba78 + r_arg2 = 42c1fee9df4f2802 + r_arg3 = 89184dd907f163bc + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = 4bf49d3f0141af2d | a5d9bf1cd7af88a8 + v_arg2 = a78aa81e0d4c504e | 8da0e05c98499e32 + v_arg3 = 8ced825717830e10 | 03a7816056c172e0 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 4bf49d3f0141af2d + r_arg2 = a5d9bf1cd7af88a8 + r_arg3 = c76ec000db292744 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = db15c28508b6f538 | 414ce45585c7d70c + v_arg2 = 8fad57870c9d1c2e | 7da072b0e74c1f1e + v_arg3 = c9b80a2a40adcffb | 8cacb7f4f9e6094c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = db15c28508b6f538 + r_arg2 = 414ce45585c7d70c + r_arg3 = 6aecf99c8cc32e70 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = 2200c58d9bc9baf4 | f0c5f9af1498abf8 + v_arg2 = f0169ab6ff259fd8 | fe09987d1ee6285e + v_arg3 = 177efd490a1e24c3 | c96bc4867d1131dc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 2200c58d9bc9baf4 + r_arg2 = f0c5f9af1498abf8 + r_arg3 = 205b4a147ac23736 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = a95062e0956ec79b | 0ffe80019715f1d1 + v_arg2 = 01788c3b504cdde9 | dc6bf4649c40a67f + v_arg3 = 976d40218b7d9ca4 | f46f95106e25e23b + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = a95062e0956ec79b + r_arg2 = 0ffe80019715f1d1 + r_arg3 = dc53bc50add412eb + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = 7db14ac8b7863703 | 4382b0a1c3dead5c + v_arg2 = 3c53fd240e2af05e | ebe69a3f26ee592c + v_arg3 = 3100f11dff9c5db6 | ca530a483cf369ae + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 7db14ac8b7863703 + r_arg2 = 4382b0a1c3dead5c + r_arg3 = 9afccc7291176a02 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = f49be60969a03e62 | 35653824b7feb57d + v_arg2 = 25b531bdae44ca53 | c1e4d6e8a9b498ed + v_arg3 = 55c32063863de6b0 | 4f7fbc6600fc27db + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = f49be60969a03e62 + r_arg2 = 35653824b7feb57d + r_arg3 = 19ca2c9cbbd67dcc + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = 671412a878bbe409 | 560cfb1ab5b37af5 + v_arg2 = 04fca550cb4ef1c0 | 7ee2eaf7f4450eeb + v_arg3 = b50e959ae7d0c8a8 | 8eeab9dd362c5684 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 671412a878bbe409 + r_arg2 = 560cfb1ab5b37af5 + r_arg3 = a03f88b0a24bdf39 + r_result = 0000000000000000 +insn vlvgp: + v_arg1 = f670e2a6d701c82a | 9ce9d2d5e625c023 + v_arg2 = a690cbe5e6e9423d | 8527ce837ffe80a9 + v_arg3 = 0dc68da550326ccf | 57d84320819fc44b + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = f670e2a6d701c82a + r_arg2 = 9ce9d2d5e625c023 + r_arg3 = baab3f09675e3b94 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 1f427f7cf88382ba | 2cad200dbc09e187 + v_arg2 = 20acc9022764afbe | 418aefdf27ad85cb + v_arg3 = db227d67146fd038 | 009b955d6b5f976f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 471361c45f8bde95 + r_arg2 = 433e4d221b2c62c3 + r_arg3 = faed26468e631249 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 70194b4fd7874ba9 | e57be5f73fe3b5c6 + v_arg2 = 8c153e6a1a7d0156 | e22ff15df04f4cd1 + v_arg3 = 2863ce806c7f4b91 | 25559e432322078c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 472c4d408f223176 + r_arg2 = 8ed9730c870d10b0 + r_arg3 = b8324afec3df7aa1 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 34768342275bf3a3 | 4e46db2789824050 + v_arg2 = cbdffee0732097f5 | 1e496d0dc2cc5adb + v_arg3 = 3e99a00d380a45e7 | 69b3c4bf3e0e275e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = e87bdd944cfba217 + r_arg2 = 84d57e9f873b11a4 + r_arg3 = d3b4ab8b9742e183 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = e5fe25f6d59ca39b | f61204d100c21186 + v_arg2 = 422ed2e3cc26252c | f1d8b47d2dbc4a65 + v_arg3 = 7063896bbc270064 | 33b3a3b977789e7d + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = e20a7c3da279a8a2 + r_arg2 = b45da1a15a1902f5 + r_arg3 = 6e7b02c240acc933 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = c4a86410f4151a62 | f5f25be4ea6d0b66 + v_arg2 = 9ef13972631676e7 | 5d6a8b7926248c0b + v_arg3 = d5ae53f363175313 | 715dccda6f9f6620 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 73f68c7083ee0fde + r_arg2 = f26bc259eab69558 + r_arg3 = b31e7cb75daa8a16 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 96756aee7d806d67 | a5c590ce39f92a4e + v_arg2 = 90a72ac9dde52c31 | 2bdcedcbc8372745 + v_arg3 = 0e74c2bd800d6a99 | 598c87476e7495dc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 202624e58458b9f0 + r_arg2 = 1884414a828e53a0 + r_arg3 = 94817d7db1f9136a + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 6735176f0f45c578 | 6afcc73a404c3eb8 + v_arg2 = 921dd02006b87bf3 | a819cdfa1518782a + v_arg3 = fc7c4c6008e888fc | 24a4926620531165 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 7311d38fa326611a + r_arg2 = c67cb0f8964e5b7f + r_arg3 = 85965fe2e441aa11 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 4b47c1aeb038257e | 6c515dd47c7aaffd + v_arg2 = a12d4e718fa0f2b3 | 6ad8d20eb395f230 + v_arg3 = 8b1fdfae5af5c55f | d25ce1975aca5a4a + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = bb7b5c6004f3537e + r_arg2 = 233799a17f8e2242 + r_arg3 = 441f313646d9a846 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 1858f3c58a5d2143 | 598fa3024d843814 + v_arg2 = 027f7932ce5b3358 | 09611949b0ecdce9 + v_arg3 = 6c009f7bf8b1d1c2 | ea745cfad35045bc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = cf367809af4836db + r_arg2 = 9a643b033d973297 + r_arg3 = 926979038b883e64 + r_result = 0000000000000000 +insn vlvg: + v_arg1 = 2e212f8dafa6a92d | 2450a2abba1aac53 + v_arg2 = fe49a1158218b7e3 | e747f7ed3f8916c6 + v_arg3 = d3d2a6564c84afc5 | 377fa52eec0dbb47 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = cce497b6545ec34d + r_arg2 = 9f424e1b341eeb4a + r_arg3 = f711f2d5904134a4 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 312cac5bd6b2bd03 | c8b9d6f33159b52c + v_arg2 = a61149ce8e328c35 | ea2eb6fc79c5d5d5 + v_arg3 = 3d14c34d64857b64 | 8c99cf0f69977f95 + v_result = 31a62c11ac495bce | d68eb232bd8c0335 + r_arg1 = d2b2a0d408d88b0f + r_arg2 = 685ebbe2ef054502 + r_arg3 = 82c24ff216e5a5de + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = ca8f18c31c8e36a6 | 063ef4fc458c90f0 + v_arg2 = 9069eacbbaf216ce | 3d8553f21da66385 + v_arg3 = 2dd63dacb73b26bb | 822f287636b1e630 + v_result = ca908f6918eac3cb | 1cba8ef23616a6ce + r_arg1 = cc1dadcd078bb63b + r_arg2 = b5516510e1208c07 + r_arg3 = 88f3f7218203c446 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 69ae5858c57784d7 | 2462a4a56fedd38e + v_arg2 = 98b0b5fc7650d28a | 134b478b50a4e060 + v_arg3 = ea758dbdde5936c2 | 35bdf1fb240d9d40 + v_result = 6998aeb058b558fc | c576775084d2d78a + r_arg1 = 26b0d1c97038bf87 + r_arg2 = 8985e4dc1fec23fd + r_arg3 = 61acc865a4999b2f + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 06fb4468fa956bf7 | ad77484ccf632853 + v_arg2 = a0d64f8b96b20e65 | 64cd3b815f6105cf + v_arg3 = 435927875c7f8710 | 0b8a22b4aa0a6847 + v_result = 06a0fbd6444f688b | fa9695b26b0ef765 + r_arg1 = 95c2d26d0c4f3a08 + r_arg2 = eff045b9285843a9 + r_arg3 = 2f40d5c16dd3c7cb + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = dcb86cc289bfc5c0 | 3459b48ee9440faa + v_arg2 = 511793a417aab337 | af64d34d796edcd8 + v_arg3 = 4cbc339158fe0d9a | 6e6c27f6a575ddeb + v_result = dc51b8176c93c2a4 | 8917bfaac5b3c037 + r_arg1 = d33bf09f08ac8ef2 + r_arg2 = b6d6cc199e7fbaa9 + r_arg3 = 971329f5b8c93ee7 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 2db2d673a83c440f | 1135f4046914a1dc + v_arg2 = d9be542ddabafc78 | b73a65e4760b89e1 + v_arg3 = 1f654d9f5e939074 | 8d89a612184b2dab + v_result = 2dd9b2bed654732d | a8da3cba44fc0f78 + r_arg1 = 614e9c3eb75dbc54 + r_arg2 = 3689b32c0b6aad3f + r_arg3 = 8654823e03440ab1 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 0206be83b27e2e9d | 22470a07df4248d0 + v_arg2 = ace2198d65113dfc | 4604bf7b93e6056d + v_arg3 = 9c674973222a6e8e | 20133718ed73dca7 + v_result = 02ac06e2be19838d | b2657e112e3d9dfc + r_arg1 = 443e42ed525817df + r_arg2 = 0a2be9a09dd15606 + r_arg3 = eec2161933780c74 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = e9de56bbe9e81fbf | 8b95ae6c84f089ca + v_arg2 = 442bdf68a54e9eb5 | edc8e54234dadedc + v_arg3 = 2ae6f28c3d9b5d76 | 21092b95b387855b + v_result = e944de2b56dfbb68 | e9a5e84e1f9ebfb5 + r_arg1 = c81c01c8b8480a9e + r_arg2 = d469d461ebd9c7b9 + r_arg3 = 866952ff54caba59 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = b63384603388cb2c | 78b80d47f3abbb2e + v_arg2 = e18cdb5faf3bde76 | c397d12ba2b0f92e + v_arg3 = 74d1c6e9ef6f271b | 94fb46575f8b9862 + v_result = b6e1338c84db605f | 33af883bcbde2c76 + r_arg1 = 41866e2b2f40d6be + r_arg2 = fd400f59aed6a6f2 + r_arg3 = 8e659728578ae227 + r_result = 0000000000000000 +insn vmrhb: + v_arg1 = 428ca7f8dedcbab6 | d7938aaaf12dcd3c + v_arg2 = 4a0836d37a9211ad | 225332a2cbe051bf + v_arg3 = 2ea7bcc5dc9b6d87 | 41c585270cb21c36 + v_result = 424a8c08a736f8d3 | de7adc92ba11b6ad + r_arg1 = c669567121845146 + r_arg2 = 72ba2d308909f0e7 + r_arg3 = 8a9cfc4bd3b86503 + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 2fbc53035d8f0b0f | 1f188165272004d5 + v_arg2 = 8a70d0a1a7ba6227 | 6e692e55054fb60b + v_arg3 = ce34ff5acf4166a2 | 7551da8cbb1e6eed + v_result = 2fbc8a705303d0a1 | 5d8fa7ba0b0f6227 + r_arg1 = f5be79b1e046a9de + r_arg2 = 69b0750bc362b72d + r_arg3 = 03870f5bc5c2fd2f + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = a3a710c1093c3284 | 0c08ffc7e4ddbb33 + v_arg2 = b422ffe63a89d2cf | ce9621eccb118f6a + v_arg3 = 5453b0a17b749ef4 | c559ec8d149f00fc + v_result = a3a7b42210c1ffe6 | 093c3a893284d2cf + r_arg1 = b24f50816364208b + r_arg2 = 1a89a54f083de477 + r_arg3 = 4ae995495043f9cc + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 09fb20f2e128bbc3 | 61b28c5adc2722b3 + v_arg2 = a1cb4dbb5f02f86e | f2a45cd07f2799d3 + v_arg3 = 03ada90f35f4b762 | cc21d86e24721bf7 + v_result = 09fba1cb20f24dbb | e1285f02bbc3f86e + r_arg1 = e871c8b6082ece6f + r_arg2 = 87f8b05e2c27f656 + r_arg3 = 359446c77ec4fc9b + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = d4f9378f4a0b0597 | a5b2e2a9ecf4008d + v_arg2 = ad243ef92717c06a | cc2ce7e72741a69c + v_arg3 = 26773558bcec2cef | e93ff3711d039e4e + v_result = d4f9ad24378f3ef9 | 4a0b27170597c06a + r_arg1 = 47ca0520511d628c + r_arg2 = 36c08057e999c1fa + r_arg3 = e0299202fe7dc2b7 + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 3c2d4194d1c608a9 | e7b3b4fcd4237299 + v_arg2 = 7eb707f549662d89 | 57554055317b6037 + v_arg3 = cd37da2ff2ba097b | 025585951aaabd0f + v_result = 3c2d7eb7419407f5 | d1c6496608a92d89 + r_arg1 = 050b2051a79be181 + r_arg2 = f272b5d99cba30ee + r_arg3 = 6ed75f66e513db5b + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 003020b8e52c0f3f | 7b2c6918fb45aa0b + v_arg2 = be995943e2ff17ae | 54921b3b302204f4 + v_arg3 = 8e7e1002a1a6b586 | 44d49058d970c4a9 + v_result = 0030be9920b85943 | e52ce2ff0f3f17ae + r_arg1 = 9eb6ea561ac16649 + r_arg2 = 8e2c65bf0c2005de + r_arg3 = c61ac95d6e5a6ea0 + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 236c6c329ebd7f00 | bc24de033057b236 + v_arg2 = dd301575361bed9a | 0866207a9d6f27c4 + v_arg3 = 44ae08c138a8a9ec | e1ba88777fc9d2a5 + v_result = 236cdd306c321575 | 9ebd361b7f00ed9a + r_arg1 = 94d8a87a1f12e202 + r_arg2 = a25adbe4248e9553 + r_arg3 = 577ce10fba13f83e + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = afd632747a6490ad | c8f028bc6484274b + v_arg2 = d0ed16db6de475aa | ff22b06f974975f3 + v_arg3 = d4b466968b2536a9 | d1541aac585a9f6e + v_result = afd6d0ed327416db | 7a646de490ad75aa + r_arg1 = 30ced5095243daa3 + r_arg2 = 4c7858dfb4b68d74 + r_arg3 = d556702191ad0c49 + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = 76b4b5f21b3f0fe8 | 47f2500671e7fe19 + v_arg2 = d511eb435732889e | cda4a1b6a4056dec + v_arg3 = e3cc07ac97b14494 | 92fbe66d95b33709 + v_result = 76b4d511b5f2eb43 | 1b3f57320fe8889e + r_arg1 = 4002e40933f62cc3 + r_arg2 = f1ccd5c635f6b0c6 + r_arg3 = fa8fb278200711f4 + r_result = 0000000000000000 +insn vmrhh: + v_arg1 = cc5731db0a5623ef | 245b161dd74543cd + v_arg2 = 2d6b9ab9294bd84f | c918feeb6e2827f7 + v_arg3 = a243bdeb3ccc0e27 | e8d845b20d14bddb + v_result = cc572d6b31db9ab9 | 0a56294b23efd84f + r_arg1 = d7adfc01e979cb57 + r_arg2 = fa2fc0ed831e96eb + r_arg3 = 465a1cf6ba2a0750 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = 4fe093dd7761055f | 53e9b07d7ad5d6b2 + v_arg2 = e0175e473ea1aa76 | d1b9c96387230ffd + v_arg3 = 842f0eb902a8e734 | 9ea304aefd2a2a69 + v_result = 4fe093dde0175e47 | 7761055f3ea1aa76 + r_arg1 = 1195bbb5028a7e72 + r_arg2 = 98c3bba7a1276f65 + r_arg3 = c0fa163a9712430d + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = a0fe43e4f885c7f4 | 8ba888a166fb2df0 + v_arg2 = 7e3f6bb5d7969d6a | 0990b9f62715a941 + v_arg3 = 0237fab9d5e0f9b0 | 445e2793c9d20c12 + v_result = a0fe43e47e3f6bb5 | f885c7f4d7969d6a + r_arg1 = cdcff4e63114a606 + r_arg2 = 82bc610379fbbf52 + r_arg3 = b380c26298652f36 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = 27addbd946150f47 | 09b302c08b071550 + v_arg2 = d9dca648dc3a61e1 | 9c32fdb6e98b4b26 + v_arg3 = 5e50b28ec941016a | f11da752b9d448d6 + v_result = 27addbd9d9dca648 | 46150f47dc3a61e1 + r_arg1 = 727d71150ff1f5a0 + r_arg2 = b21b018e99322030 + r_arg3 = 728ab4cc01390cf7 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = d3f7ee660454d98d | 54f3349182f971f5 + v_arg2 = cd746e859a0a81ad | 7a85f7b79241e6ef + v_arg3 = 5e7c6298d88315d3 | ffc03557bda7d811 + v_result = d3f7ee66cd746e85 | 0454d98d9a0a81ad + r_arg1 = ab90b240dba8382f + r_arg2 = 2c6c6216f8d2049a + r_arg3 = 1604b8cf3fd1b059 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = d8b5c3af7830395d | f4ddac06473efa23 + v_arg2 = f9dc56ee83b11b7f | 197a03c8cbe0be78 + v_arg3 = 0d8ce9b49f0f5fb7 | d1b6f64f2a328e3e + v_result = d8b5c3aff9dc56ee | 7830395d83b11b7f + r_arg1 = 2b86ada13b300fbc + r_arg2 = b78e7e63b00d7007 + r_arg3 = 3ce99085a05e4803 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = 714d171950081769 | 39372e13fd73fefb + v_arg2 = 83f6e8c2f2c9a3a6 | 35d22e37e2c02e01 + v_arg3 = 7edd9cff25bae000 | 91bb45e47b88d0b7 + v_result = 714d171983f6e8c2 | 50081769f2c9a3a6 + r_arg1 = 6b2b8d75f9aab031 + r_arg2 = a26a47fec205c390 + r_arg3 = c801b3831ec118f9 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = 9c74df055f65f142 | fbd27466ae20223b + v_arg2 = d87365c0e59aa4ce | 91dcff908da766e2 + v_arg3 = 891e079295872f79 | eb99757e11aa5a72 + v_result = 9c74df05d87365c0 | 5f65f142e59aa4ce + r_arg1 = 675a73b1c729a915 + r_arg2 = 81b965edd58a6ea9 + r_arg3 = a4a4109d1646365f + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = e2ec04945ec39d18 | 554fed2f087c2100 + v_arg2 = 6a9180e4c1d87fc4 | b433335da7872d56 + v_arg3 = 8c07ac4500673787 | d3e98d03f44700c4 + v_result = e2ec04946a9180e4 | 5ec39d18c1d87fc4 + r_arg1 = 65bc38cdfd6c9b4d + r_arg2 = eec1f674f8d9bae5 + r_arg3 = 8274caa609695436 + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = 0c462664ac480676 | 69dd7fd9222e8b86 + v_arg2 = 71dc272612672a30 | ac8379e6f2429f34 + v_arg3 = 2c21c36e1cfbfdf0 | 45d10b96917d6a21 + v_result = 0c46266471dc2726 | ac48067612672a30 + r_arg1 = af862a7c56a000db + r_arg2 = 4a174ed45c5d85b6 + r_arg3 = 9725fa2c6293741c + r_result = 0000000000000000 +insn vmrhf: + v_arg1 = ef9f5a500f89eb08 | 20f745cd360987e5 + v_arg2 = abef3b404919f358 | cf443bf0d567f0af + v_arg3 = 1283f9a2084f5896 | 01c6a25a7a98d7d8 + v_result = ef9f5a50abef3b40 | 0f89eb084919f358 + r_arg1 = 543dcb70b722e7a1 + r_arg2 = 7a5db50e1b700629 + r_arg3 = 5e37713e30dcb20f + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 2265ed32714ba356 | e829523565cd92d5 + v_arg2 = 1d3253677d6d3be2 | 767c55801cf5281c + v_arg3 = b0923272069fb73c | 4c4afc2e2ad0dbda + v_result = 2265ed32714ba356 | 1d3253677d6d3be2 + r_arg1 = ec749619e93ab31e + r_arg2 = ab042d9ff51985ac + r_arg3 = 5bb97329e8c9fe29 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = c3121fa3a53edc89 | 74cb6eb576ec3e6a + v_arg2 = d09c7e102c503d91 | c180dc98bb16e6ab + v_arg3 = fabf482e4014df3e | b2ad7971bf0e2273 + v_result = c3121fa3a53edc89 | d09c7e102c503d91 + r_arg1 = 518bba655adfe02d + r_arg2 = 0e092a440ece24cb + r_arg3 = d6077e35250edf64 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 36efe9b820c35824 | 80c3d4319841f4d6 + v_arg2 = 9572feabf7dfc506 | 57b2d8f78be41f2a + v_arg3 = 2d4bc9a48586ab5b | c7cfefbfbfa72b0d + v_result = 36efe9b820c35824 | 9572feabf7dfc506 + r_arg1 = 6771dd80e078becc + r_arg2 = 9dbb58b6b2329aed + r_arg3 = 9d8a016b694c3255 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = e7d1b8c5c1a6afcb | 8b46fb8d1cd8b32c + v_arg2 = c2050f6a6922f97e | 23430bdc0b26dcc8 + v_arg3 = 8c04bddf093acc6e | e1db68b1d41d0ef2 + v_result = e7d1b8c5c1a6afcb | c2050f6a6922f97e + r_arg1 = d661db94779734d2 + r_arg2 = d571596d11d7f319 + r_arg3 = c37d2651dad3e9f3 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 04dd301c89e310ff | 9c964a673daccf1a + v_arg2 = f3769ef9b1d01499 | 18f0a9c22112ffcf + v_arg3 = 1f085feb29a4872f | e00ce89f90e43709 + v_result = 04dd301c89e310ff | f3769ef9b1d01499 + r_arg1 = cba78689febf7fb5 + r_arg2 = 7a57846004fc51b6 + r_arg3 = 64a589aa0660cd50 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 4446ebcd646301de | fec3e2ddd862b4ad + v_arg2 = cb73124664102710 | efc71e23d70cff67 + v_arg3 = 7380df8f25257af5 | e76a255f2a192997 + v_result = 4446ebcd646301de | cb73124664102710 + r_arg1 = bb5b64c5ff1ef14d + r_arg2 = 5721a8c2c74eaf45 + r_arg3 = 5e17ff399fde3d5e + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = a30c3867dfbe1be6 | 046d594c3412a110 + v_arg2 = b1fa07393d34d77c | e4e2cc382063a859 + v_arg3 = 5d642710e5cd5775 | 218c4d063f4b3cff + v_result = a30c3867dfbe1be6 | b1fa07393d34d77c + r_arg1 = 212374eb6552b48a + r_arg2 = fcd4c8c5bdaa9928 + r_arg3 = 1af5517e4027eeaa + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 23beddb4f1f9cfb1 | c67f7a0dbcfd6e4c + v_arg2 = 94140f7cde7f2214 | 7d29cbb69119ddc8 + v_arg3 = b73c94f3b618a883 | 7d57c5a493356081 + v_result = 23beddb4f1f9cfb1 | 94140f7cde7f2214 + r_arg1 = 3bf4e99e4427853e + r_arg2 = 7e83dd5930d7f65d + r_arg3 = 4230ff7627c2a922 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 8d37d67fb34825b8 | e2f40739c1574808 + v_arg2 = a89970328ddf1b6e | 4413a891289b57f7 + v_arg3 = 22dcb9b90ab38acf | 73bbe40bce80d8fc + v_result = 8d37d67fb34825b8 | a89970328ddf1b6e + r_arg1 = d2d0ee3d955579d9 + r_arg2 = 3b0e98ec0f4fbf42 + r_arg3 = 8945fe5ef9a511d1 + r_result = 0000000000000000 +insn vmrhg: + v_arg1 = 2f63145028cc7813 | 3d9477653afd7048 + v_arg2 = 27f1eac2f8b2a93c | 896527bc09836409 + v_arg3 = c32620a33b3773a7 | be7bbd88408401ae + v_result = 2f63145028cc7813 | 27f1eac2f8b2a93c + r_arg1 = ef8761a7f745bc26 + r_arg2 = 95e31d2aaff6c651 + r_arg3 = 67027b6f83f35ba0 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 9dfa3f2df6543c36 | c1b6b865833eff30 + v_arg2 = 12d06e8cf1834d0e | 21ef01e53d5ba8ba + v_arg3 = 07ca096f49ebedba | 20e5d3a79e0609f2 + v_result = c121b6efb80165e5 | 833d3e5bffa830ba + r_arg1 = a77999f770cb4e12 + r_arg2 = b3c0c9bc8adf70e4 + r_arg3 = da4196a174be1416 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 714175592b1fb8b4 | 1dfeef0b2294a5c0 + v_arg2 = eef8e8b133ccda15 | 2a54a73c725ce02a + v_arg3 = 5f082a18988558d2 | 2294e3f1c3f9b9ff + v_result = 1d2afe54efa70b3c | 2272945ca5e0c02a + r_arg1 = d15121482becc564 + r_arg2 = 436eee0c040c7cf1 + r_arg3 = 27aa286b24c4df17 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 0bcf0917fa97cdfe | 881f34e77e6b6698 + v_arg2 = 87f9f7ce1cb53bdd | c5c2fe2bbf299b91 + v_arg3 = 056b6d98b4e8ad97 | d1349eb071402dae + v_result = 88c51fc234fee72b | 7ebf6b29669b9891 + r_arg1 = cbc97b7138980e84 + r_arg2 = 3b8593fe212dbacd + r_arg3 = 97747e7f503535a7 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 524545677d15ae23 | 7f995707a6d75db5 + v_arg2 = b1f3b0c072d23011 | dab4211d5d98ff0a + v_arg3 = b68eb6a80ee63651 | 833d6ca80e6a9634 + v_result = 7fda99b45721071d | a65dd7985dffb50a + r_arg1 = 3a6cdfc84f6f2d36 + r_arg2 = 942d35b7515fd5eb + r_arg3 = 3b231c91dc6a24a7 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 711329c671a3a690 | 837a9fb711607930 + v_arg2 = 02505f601fe8123a | d9b6233a6f688b4c + v_arg3 = 76d99b7dbcfd57a5 | 90b52bdd6773ffe2 + v_result = 83d97ab69f23b73a | 116f6068798b304c + r_arg1 = c74dfae18e7ff85f + r_arg2 = 0eda895925ee0b9c + r_arg3 = a94a7c1090ad1195 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 9c392bf0fdb3d6d0 | dc20864159b94305 + v_arg2 = 9a8d4647f5a78b7e | 741fcb28bc0ad06a + v_arg3 = 50432a8b3d1d4956 | 1af0ef53718806eb + v_result = dc74201f86cb4128 | 59bcb90a43d0056a + r_arg1 = e3d4af4f3702e1be + r_arg2 = f00e38c31812f0d0 + r_arg3 = be49cdeadcf7774f + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = c902f6a06bebf44c | 5af37eadff8397c8 + v_arg2 = dcf15d896b6f6063 | 66d757cb705b3799 + v_arg3 = 1410a844345fda04 | c752c0c804c29f1c + v_result = 5a66f3d77e57adcb | ff70835b9737c899 + r_arg1 = 8470d9617423aab2 + r_arg2 = c519a25447b32fd2 + r_arg3 = 5b0eb54b95aba6cf + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 78c82c4deedc0e0a | 0f2eb0812b0d6770 + v_arg2 = 3353117c5e0e288c | 30123a04df66bfe8 + v_arg3 = 18924cd929cd30ee | 820a607a9fe8d5a4 + v_result = 0f302e12b03a8104 | 2bdf0d6667bf70e8 + r_arg1 = e66408e413b92ef9 + r_arg2 = 20da9ca73928490e + r_arg3 = 28d6105cb65e85ef + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 6cb524ed5bc54571 | 1696b88069167c0f + v_arg2 = cfd70571d27e1279 | d812de744225bc08 + v_arg3 = f8eb09f64b1f83b2 | 3ed702e6283089cc + v_result = 16d89612b8de8074 | 694216257cbc0f08 + r_arg1 = 4c7d41e64a091f6d + r_arg2 = 597e325799f254cd + r_arg3 = 54ecaf0721925024 + r_result = 0000000000000000 +insn vmrlb: + v_arg1 = 6f7facb5f1539302 | 503f6a6d6e883596 + v_arg2 = 65b0d578afaaa34a | a8e7633878409905 + v_arg3 = 56c84288317be70b | b3c61485a9fd32be + v_result = 50a83fe76a636d38 | 6e78884035999605 + r_arg1 = bdd9bf6f7587c3c8 + r_arg2 = 4f3f67bbf884bef6 + r_arg3 = 53681ab05c745b45 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 132ac9d61262871e | 224d91c7d13c4694 + v_arg2 = f3decf1f8529767b | f5305eacc7cb970a + v_arg3 = 9b27947a95330091 | 1ff1f79014a09c41 + v_result = 224df53091c75eac | d13cc7cb4694970a + r_arg1 = c8a0b448d494b760 + r_arg2 = 2525f1a98dfd09ce + r_arg3 = 9fef4efc55a4ce44 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 6cc9734008bb04c5 | 39afac8dd3bb7af6 + v_arg2 = 7befb8324a00fba8 | d6da9c2b9a0a8d1f + v_arg3 = b51090711889cc7b | 0740c3bc001aa97a + v_result = 39afd6daac8d9c2b | d3bb9a0a7af68d1f + r_arg1 = 41cd09b74e3fadea + r_arg2 = 05c7fe35f5eb8db7 + r_arg3 = 7978818d1eed68f2 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = d83b5a60c1d60654 | 46e4b0fa18fa73c7 + v_arg2 = c3c08e7b17633a49 | e9deddcd412fa7ec + v_arg3 = d85e7e96026d5d5e | f42a05fd6ad714ac + v_result = 46e4e9deb0faddcd | 18fa412f73c7a7ec + r_arg1 = 02e51a4031062f39 + r_arg2 = e109f272f30839f3 + r_arg3 = a604dac2b2073ebf + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = b8f1a5e493995d45 | c3b9c9496c1c65ef + v_arg2 = 1c3c4182ee728d76 | 13069b26b5192876 + v_arg3 = 3e751c4c003c9cee | 38738045767329f7 + v_result = c3b91306c9499b26 | 6c1cb51965ef2876 + r_arg1 = abbc7c64f0955aff + r_arg2 = 2ddd262e31ff5360 + r_arg3 = 32633a7aaf5a7976 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 35a5ae75fa1671f1 | ad0819718032dff7 + v_arg2 = 191a784c77ff6aa2 | 3da8c10c511628e0 + v_arg3 = e70c5df4e48108ba | a7edef442c778f1a + v_result = ad083da81971c10c | 80325116dff728e0 + r_arg1 = 6336b864e585a389 + r_arg2 = a705abb9fe27343c + r_arg3 = 31f4f7d01bbc1c03 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = fc22c77a564ffd50 | 497978e8abfd83c2 + v_arg2 = 53a2531ebf451762 | 186874509aa0572a + v_arg3 = 5ae32cae69b676f3 | 5e3ac2283c1bff33 + v_result = 4979186878e87450 | abfd9aa083c2572a + r_arg1 = 95020efe0d1d9686 + r_arg2 = 0fce069d0f450de1 + r_arg3 = 79649cde2031bc2f + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 0302f8daaef4d4b5 | e0423363aaa9ca54 + v_arg2 = 2c67243af9b17426 | daf9ce82f922b8f4 + v_arg3 = 628d2719ec02d025 | 8087dd5ebc040a7d + v_result = e042daf93363ce82 | aaa9f922ca54b8f4 + r_arg1 = b55f332ccf1292bf + r_arg2 = f0d5f3653f4ca688 + r_arg3 = 6a6caa7dd0a94661 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 426ac0b97121a095 | 83e9cd926092c28d + v_arg2 = 8a0d359f3e9bb6fd | 00da9eb07db3683a + v_arg3 = d226651135fcd6fa | f5515e4ee506d80f + v_result = 83e900dacd929eb0 | 60927db3c28d683a + r_arg1 = f9da14ebb6498fde + r_arg2 = 56c523594f1f1a09 + r_arg3 = a7965a02e2c3bd5d + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = 7bced03830249e40 | c700c2e79701cfed + v_arg2 = 980386cc4d0c2753 | 0a1b2a269ad85518 + v_arg3 = 421b316f2d65e0fd | 2a235420d9e3e4a2 + v_result = c7000a1bc2e72a26 | 97019ad8cfed5518 + r_arg1 = 210c91f03292d92a + r_arg2 = 9715fe3fa74c9c98 + r_arg3 = dbf85a01748ff907 + r_result = 0000000000000000 +insn vmrlh: + v_arg1 = f3b1d438653464a6 | 8be6404fbeee6e51 + v_arg2 = 89488c7c4c78e8b5 | 4318ee2ded440886 + v_arg3 = d1e8cdcba5f09a53 | d454897c6108c24b + v_result = 8be64318404fee2d | beeeed446e510886 + r_arg1 = 305f43735b6ed348 + r_arg2 = 0bcd621b13d13688 + r_arg3 = 76f68c0cc7466a20 + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 38642a172f399c12 | ae8becf5aabeedb2 + v_arg2 = 5528f46a8584af8b | 773c5bcff69a5c1b + v_arg3 = e2d4303b16fcc882 | adcc3944a855da3b + v_result = ae8becf5773c5bcf | aabeedb2f69a5c1b + r_arg1 = 31c937e7afc9b6fa + r_arg2 = d44062ee88da850b + r_arg3 = 6e02cb740713d406 + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = d9c6a9701489c7f0 | da2ba405560535ec + v_arg2 = 7bff5f0d2ac089db | babe9990dc2845cc + v_arg3 = e0b5c9145c56002c | 35bed95b01d42a85 + v_result = da2ba405babe9990 | 560535ecdc2845cc + r_arg1 = f38eb1bed0bf50e2 + r_arg2 = 97d20879dd7f7fee + r_arg3 = ff5ea70501cd1177 + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 31015dddbfa7fb88 | 3d113765a3448273 + v_arg2 = bdf4245b126d990b | 296646352dac8bad + v_arg3 = fab13ba77bfa73d3 | 736dd261a77f08d6 + v_result = 3d11376529664635 | a34482732dac8bad + r_arg1 = ce00ea284859c63e + r_arg2 = 41b214f993892e5f + r_arg3 = 6bd724ccebb8d34d + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 1e5246b7c005a5c3 | 4b542f7c19ab251e + v_arg2 = e8bd11887b37d89e | a14736809c118cae + v_arg3 = e7f91f035bd2a596 | b3ea447378fdde3d + v_result = 4b542f7ca1473680 | 19ab251e9c118cae + r_arg1 = 5d41d3d3464f52ac + r_arg2 = c39fbceb8e2d73a9 + r_arg3 = bb8a7fd3204a6041 + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = c2bf1cd350c249e4 | 7e9c89eea4d649df + v_arg2 = 8a602ac7c6fad4f4 | 8a8531f0c332fe5e + v_arg3 = a48fc5b88c7431f1 | 47d3c4edba64ede3 + v_result = 7e9c89ee8a8531f0 | a4d649dfc332fe5e + r_arg1 = 42fed1ab5ec606e6 + r_arg2 = d7a56bc8dacdc4f5 + r_arg3 = 7da1e9e2e2e254ab + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 4ae10e450b6b3e4f | 16dc785c5992ac87 + v_arg2 = baee69063f7f720d | 8f0fb884df95aba9 + v_arg3 = 3200f49102e7877f | 46151e2ad7f70bd2 + v_result = 16dc785c8f0fb884 | 5992ac87df95aba9 + r_arg1 = e634809a4d128886 + r_arg2 = bae082c868bdef0a + r_arg3 = 84154b3f1791633f + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = a49b7f1fb4bc7345 | d917262730986284 + v_arg2 = d5497db5d33ead45 | 6464c177972f349c + v_arg3 = 5a29a657da5daeba | 50a9144121e866b1 + v_result = d91726276464c177 | 30986284972f349c + r_arg1 = 36ed7147b374d5c2 + r_arg2 = f1361aa2cffad50d + r_arg3 = ac6d016e0dd415d0 + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 47dfc831f55f2da4 | d51e732cc74f96a5 + v_arg2 = 3cde8c7ed81c5518 | 7f507703b625d01e + v_arg3 = 69f4ce9415f903b8 | 49591ec890164085 + v_result = d51e732c7f507703 | c74f96a5b625d01e + r_arg1 = 6802ecdad7dbff2f + r_arg2 = 0520c1480cf33040 + r_arg3 = 947c9ff03757890f + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = ef6efac91caac7a9 | 1a4fb488268d49d4 + v_arg2 = 176af20dca2dd1de | e0aefc21ec870bb7 + v_arg3 = f41b124c5989f8ef | 1a7a29937fceb170 + v_result = 1a4fb488e0aefc21 | 268d49d4ec870bb7 + r_arg1 = b4daaeb567a6ef80 + r_arg2 = 476139ae43424fc5 + r_arg3 = 6325b005eeb2334b + r_result = 0000000000000000 +insn vmrlf: + v_arg1 = 5f979a73e06471b0 | 82577654765512da + v_arg2 = 15b700c80872de8e | ca2727469215874c + v_arg3 = 96e291c4b34bd6f0 | 74b25975738c6874 + v_result = 82577654ca272746 | 765512da9215874c + r_arg1 = 1c28ad3b375f2447 + r_arg2 = 8dcb3d837c73d55a + r_arg3 = 8419736c312e9f31 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = 1ef663ba1a7ff2f2 | 69ef3969c999dd1d + v_arg2 = 2b5ebe969b9a4e7e | 88f0472664fdbfe0 + v_arg3 = addf9f3d58aa7c2e | 8cb2c8fdd4ba6b30 + v_result = 69ef3969c999dd1d | 88f0472664fdbfe0 + r_arg1 = 25afd08bfe8072b1 + r_arg2 = f3ff3df567ba7e1d + r_arg3 = 6a969d21667f2c8c + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = 3b3608e38dde6744 | 75a1361bd5f8ad64 + v_arg2 = 5186aa9af0c3cb20 | 2a8fdf744599bf53 + v_arg3 = 22b485b85f011eb6 | e0fc4538b36ed3a0 + v_result = 75a1361bd5f8ad64 | 2a8fdf744599bf53 + r_arg1 = 9d00b8441c30c54c + r_arg2 = 9c2c1d7018c0da48 + r_arg3 = 4d291a1d178ad205 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = 0acef0b7a00f02dd | 50821a00ba7f5a8f + v_arg2 = 48a277f89a3992c5 | 4595689eff34ee25 + v_arg3 = 1fd243b3895508f7 | f29d1574832f91df + v_result = 50821a00ba7f5a8f | 4595689eff34ee25 + r_arg1 = 54397a415705dcc4 + r_arg2 = 6fcefa5ecc5510f4 + r_arg3 = ec6bcc18b61fdde3 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = e5c5f8381f0fcd0f | 69f8c9a9b86a5462 + v_arg2 = 5735d08d1235385b | b764129300c5c532 + v_arg3 = d6374ee9fb1e597a | 09f1b6fae0af2ce7 + v_result = 69f8c9a9b86a5462 | b764129300c5c532 + r_arg1 = e3c6635d9ac20fa0 + r_arg2 = db6fe5e6a43d9dd9 + r_arg3 = 4ac64a485bbeafca + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = ed703569fe0c650b | b8741d67fae35e3a + v_arg2 = 0a9013ba779e6931 | 61e984801fb19576 + v_arg3 = 412f5214fffdc9aa | f46598d14c90814e + v_result = b8741d67fae35e3a | 61e984801fb19576 + r_arg1 = 6823b42fb6180a08 + r_arg2 = 9368a6b066e7140b + r_arg3 = 712fa3228155837e + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = c731b00a171dbfa0 | 7837a5064fc054d4 + v_arg2 = f39117184fcaa4b1 | ec60988d558c46c9 + v_arg3 = de16f1adc685648c | c62fe380ed228309 + v_result = 7837a5064fc054d4 | ec60988d558c46c9 + r_arg1 = 489664cd21689080 + r_arg2 = 53a07c9e3f2fdcbd + r_arg3 = 33ec1a17cdfe26a0 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = 5f392958e70be7fb | eb106793ec47e70c + v_arg2 = 6a64e743453c0123 | 861620a385d713a2 + v_arg3 = 6f1283a929f54d86 | 9b1635cb5122f92b + v_result = eb106793ec47e70c | 861620a385d713a2 + r_arg1 = ecf8e18bba7e39ac + r_arg2 = 9b4ad8928422f601 + r_arg3 = e44ee857c7c4bc6e + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = a946d5cf550abd67 | 191b9f182ced5c9a + v_arg2 = 4d448593e965ed70 | a221a52836c14fd6 + v_arg3 = c0dcd53c64fb7d1a | 522f61732b7b44a6 + v_result = 191b9f182ced5c9a | a221a52836c14fd6 + r_arg1 = 856bd0bc8356350d + r_arg2 = 6fa9262e6db9b484 + r_arg3 = 2176fe8fa05e8186 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = 5b6421ea6c7eb70d | 92827e5c501152d5 + v_arg2 = c03aa8dc7366e9db | bc2823bf54e92459 + v_arg3 = 6176eb98db7182aa | 529c31f914071707 + v_result = 92827e5c501152d5 | bc2823bf54e92459 + r_arg1 = c923c96e66da08c2 + r_arg2 = 1ece848dd89b8354 + r_arg3 = 8d13c1adebf186a2 + r_result = 0000000000000000 +insn vmrlg: + v_arg1 = b5ae6de01db9a2b3 | 283eeca740c47973 + v_arg2 = eedb7f3480cb4ec7 | 1320cf0bf4184ffb + v_arg3 = 68f4bfadd6224135 | 464e255a4b4e3c3d + v_result = 283eeca740c47973 | 1320cf0bf4184ffb + r_arg1 = b5201c31f2a04c46 + r_arg2 = f857890d0ddda39c + r_arg3 = 9021cc9a64d1715b + r_result = 0000000000000000 +insn vpkh: + v_arg1 = 3b0dd267feba617f | b7d5477b49835c46 + v_arg2 = c70d6cacd4500c77 | 6d0bd26c0d0ae62a + v_arg3 = 323600ea4585b417 | e1c333d376445651 + v_result = 0d67ba7fd57b8346 | 0dac50770b6c0a2a + r_arg1 = 4af18fcf1bae7337 + r_arg2 = 1730000875c4ea65 + r_arg3 = 17aab2fdad3e3ee9 + r_result = 0000000000000000 +insn vpkh: + v_arg1 = 75f6dd740eefadb4 | dd1c235bdef919ff + v_arg2 = c1c1ca14189e67c8 | d8ba0bbf3f2513b5 + v_arg3 = 1fabd3f97d7fadcb | 9bc7859d5f0d9b2d + v_result = f674efb41c5bf9ff | c1149ec8babf25b5 + r_arg1 = 50721e14fe38830b + r_arg2 = 1754ab9562818556 + r_arg3 = 5787b9fe0c2a01df + r_result = 0000000000000000 +insn vpkh: + v_arg1 = b62f52f76ff2d473 | c3f5088657c024ed + v_arg2 = 98b8a9ba9a0ebaf7 | 648ad220913ed786 + v_arg3 = 590f9685f92392ab | 73353fb1b9bb9658 + v_result = 2ff7f273f586c0ed | b8ba0ef78a203e86 + r_arg1 = 168dba869b60d8db + r_arg2 = de8b024acbf2b873 + r_arg3 = 8b1ea1fe2ff0a2f2 + r_result = 0000000000000000 +insn vpkh: + v_arg1 = d389eba22b4e7b7a | d31137bbb51f08bd + v_arg2 = 0e418d2a10633560 | ea2ab0aa2b5ac965 + v_arg3 = 8e2c99f61b741fad | acb53784d90debb7 + v_result = 89a24e7a11bb1fbd | 412a63602aaa5a65 + r_arg1 = 30fb0c2c9af3e61b + r_arg2 = 562df2fb0d669ae1 + r_arg3 = b1245c62e91d9fb3 + r_result = 0000000000000000 +insn vpkh: + v_arg1 = e8a517a2f13a5de6 | 80ae66f55dcc2639 + v_arg2 = acf733ee56929f3b | c8522835216ad4ba + v_arg3 = b29be431e9202827 | 917fbbca7d31134c + v_result = a5a23ae6aef5cc39 | f7ee923b52356aba + r_arg1 = 380230490731f55f + r_arg2 = 2fdc9e7aac58da9e + r_arg3 = 515bd448f329ce4f + r_result = 0000000000000000 +insn vpkh: + v_arg1 = 17b1bc62d55b0af3 | 0258802fd9ab740c + v_arg2 = 80864d4d2c7c145f | a38b7215290cfd4a + v_arg3 = bf82f45cd046558a | 3115503589811df9 + v_result = b1625bf3582fab0c | 864d7c5f8b150c4a + r_arg1 = 8f377a211684e416 + r_arg2 = 9e4c225810317d4c + r_arg3 = 3754a94fac3d1a54 + r_result = 0000000000000000 +insn vpkh: + v_arg1 = 492bf64e1484a9b9 | 17aa67209b8c407b + v_arg2 = de66410ff9b1c801 | 24ec3be05f4f1bf8 + v_arg3 = 76567e97652fe529 | 230b6e35c6486c3d + v_result = 2b4e84b9aa208c7b | 660fb101ece04ff8 + r_arg1 = 1a3c35b1e146e750 + r_arg2 = 21fd4ba149099ee5 + r_arg3 = 352cf052daee426d + r_result = 0000000000000000 +insn vpkh: + v_arg1 = ec9cd68cce78b7f0 | c30cb2febaefeb2d + v_arg2 = 209dee368b2ec375 | bdda6727096e9d84 + v_arg3 = 1b992cc220176cf1 | 44c145b8a27d7cf4 + v_result = 9c8c78f00cfeef2d | 9d362e75da276e84 + r_arg1 = 05825f7a257f497b + r_arg2 = 39fe61a2cc662d86 + r_arg3 = e351f52b68ff9d23 + r_result = 0000000000000000 +insn vpkh: + v_arg1 = b35d24c3cba5c6ac | 1275703db3c1b0e2 + v_arg2 = 668068c4d51ea4eb | 62c6cf394e92484d + v_arg3 = 3d9b5c3c20e49631 | 75267beaf3849d19 + v_result = 5dc3a5ac753dc1e2 | 80c41eebc639924d + r_arg1 = 84066f3509a32b20 + r_arg2 = 2faadea634fab128 + r_arg3 = 5f3dfb732621d99c + r_result = 0000000000000000 +insn vpkh: + v_arg1 = 5a541ed737e93f20 | d22ae350291e5b3e + v_arg2 = 5771b87bb09b6032 | 50f104e6fd93f712 + v_arg3 = 6c3ce4a1eaebe252 | 5f75ecf5b5f3b686 + v_result = 54d7e9202a501e3e | 717b9b32f1e69312 + r_arg1 = 8e16109ed85644a9 + r_arg2 = d06d35b302670761 + r_arg3 = 0d39f83f8cb4b85f + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 60b637a96650215d | 5a7c4666a710127e + v_arg2 = dea19e969b6c0076 | ca290b394db75bab + v_arg3 = 02a7d1892ab1689e | 2ffa69c1c84904b1 + v_result = 37a9215d4666127e | 9e9600760b395bab + r_arg1 = a00ce42dc32aa01d + r_arg2 = 327f8d505efd2126 + r_arg3 = 581a5ae37886d20d + r_result = 0000000000000000 +insn vpkf: + v_arg1 = cbc5dada92d2c112 | 468c892c5a4d103f + v_arg2 = eecd4f937cc76704 | d88c1f3c986fb9d3 + v_arg3 = dc17234f71a694fd | 5acd7bb3b3b8d96f + v_result = dadac112892c103f | 4f9367041f3cb9d3 + r_arg1 = 811143d6a05e61e0 + r_arg2 = 6da68340d578c88a + r_arg3 = 7005c5b1ec925627 + r_result = 0000000000000000 +insn vpkf: + v_arg1 = e99125889918884c | 39081090d8fc663d + v_arg2 = 400337ec5e0f0904 | 074373b61f20afe0 + v_arg3 = 1e9494c6f6eae9b1 | 5a941e7064db5fb3 + v_result = 2588884c1090663d | 37ec090473b6afe0 + r_arg1 = f9dafacfae9f8276 + r_arg2 = 63f7ec461ac55b7e + r_arg3 = 0b2dd3b9d1c1cacd + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 0abaaf0ec036b936 | 9aee787adc70b910 + v_arg2 = 105db8d83196b53c | 2c46eeeec9d6ef88 + v_arg3 = f3b54f03560bbf20 | 7044869aee7e534f + v_result = af0eb936787ab910 | b8d8b53ceeeeef88 + r_arg1 = 996c0c4950c98f40 + r_arg2 = 7a9491e2c5bd8f91 + r_arg3 = 2592d389b8abc77c + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 472b42c6727128d8 | 5846529307e907ef + v_arg2 = e4c3ea0d8d5b4dd2 | 211dee68e511039c + v_arg3 = 4a5fb91955c40689 | 61dfde914a5ccbb0 + v_result = 42c628d8529307ef | ea0d4dd2ee68039c + r_arg1 = 76da7534cea66f3d + r_arg2 = 5d6ef21117e72db0 + r_arg3 = c1c38bee9455bfce + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 3edfa2c902f905db | a7ebe701a1586370 + v_arg2 = 46ac5a7f70cb8a09 | 879c06a6e47b08cf + v_arg3 = 9b822cd79bbe02cb | 3a35043218daf0a5 + v_result = a2c905dbe7016370 | 5a7f8a0906a608cf + r_arg1 = ee04e2fe17ac1bc8 + r_arg2 = bf020410b539d8e6 + r_arg3 = a69bf6b082f3b73c + r_result = 0000000000000000 +insn vpkf: + v_arg1 = d49e45ab66ae9042 | c142f328571ab445 + v_arg2 = 85ddcc21fc82ba01 | 83a5c0e721ad746f + v_arg3 = a1e1b78b78510d24 | 0da64f995bd0c517 + v_result = 45ab9042f328b445 | cc21ba01c0e7746f + r_arg1 = 63587b5382c2655f + r_arg2 = 181ef31869d6c51c + r_arg3 = 2306075881a60dde + r_result = 0000000000000000 +insn vpkf: + v_arg1 = f3bf1a42fbdee231 | a6006b69fcbb7bff + v_arg2 = 7926f9a13a0a827a | 81e85cea99f1d128 + v_arg3 = 1ecae0c0a14259ef | b2dd4ae1413fdfd0 + v_result = 1a42e2316b697bff | f9a1827a5cead128 + r_arg1 = fc949add89fab258 + r_arg2 = 669ce221e5d081d9 + r_arg3 = ccbc65eb3b3e3428 + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 4ae6435f4404aba8 | dde738e549b38bcd + v_arg2 = 3d2a522edb999c90 | f5a58faab3fa7fc7 + v_arg3 = 9bd86302f185ab64 | 879477e1d91a2b37 + v_result = 435faba838e58bcd | 522e9c908faa7fc7 + r_arg1 = 678192048d57c1ac + r_arg2 = ee24a7a180e6af02 + r_arg3 = 3b022eafbbf774ad + r_result = 0000000000000000 +insn vpkf: + v_arg1 = 10c6dc93ab89ef47 | 3287f9399d2bcf3b + v_arg2 = f317bc35f2d69a7f | 16674621faac77f3 + v_arg3 = 25b7f2972afb225a | 31560defdc01ad11 + v_result = dc93ef47f939cf3b | bc359a7f462177f3 + r_arg1 = 9ab769ad968762af + r_arg2 = f9ed904df745c899 + r_arg3 = d06fb5e4353eabde + r_result = 0000000000000000 +insn vpkg: + v_arg1 = c2dfb2ea3f85c90b | 76ffc542bdb707f6 + v_arg2 = 8368521ebc93a25f | a2c96208dfd803f4 + v_arg3 = 12dff346b233ee06 | 5936bb9f65ff3c40 + v_result = 3f85c90bbdb707f6 | bc93a25fdfd803f4 + r_arg1 = 8e5e9ffd10a840d4 + r_arg2 = 987b21d62e49da7f + r_arg3 = 72a4458ac26c0fca + r_result = 0000000000000000 +insn vpkg: + v_arg1 = e13f0cb1747d280e | 43bce8d9951b8c86 + v_arg2 = 5da92712589230e7 | 9d337a9479ff876f + v_arg3 = ba564513572c1abb | 709c6484b9524786 + v_result = 747d280e951b8c86 | 589230e779ff876f + r_arg1 = 03eae6168f05996d + r_arg2 = 6161d4aced3c4a35 + r_arg3 = 4c11dc202188eade + r_result = 0000000000000000 +insn vpkg: + v_arg1 = b5436632e7259549 | b638a297f60a0811 + v_arg2 = 333102b79043d82c | 129b9c39450d3c27 + v_arg3 = 3f70fb000b1044ab | 6cf7e1ec01229341 + v_result = e7259549f60a0811 | 9043d82c450d3c27 + r_arg1 = 3fdde8d78dd80167 + r_arg2 = 31ffd8bda4149395 + r_arg3 = 91b6f16278085da5 + r_result = 0000000000000000 +insn vpkg: + v_arg1 = 0d563275191dec53 | 33bbeb9057e1401d + v_arg2 = c0e820f18f830262 | d1480c69e61ef1bc + v_arg3 = 479120cba9f860a3 | 898ac3a70b47fa2f + v_result = 191dec5357e1401d | 8f830262e61ef1bc + r_arg1 = d087049f28092310 + r_arg2 = e843d2342838059c + r_arg3 = 3add2f09128f1e88 + r_result = 0000000000000000 +insn vpkg: + v_arg1 = feb096ff2fb71f22 | 251c321a966ecb4d + v_arg2 = 8502f6a1a95ead99 | 30890454e63cc96e + v_arg3 = bde872b5afad79d2 | 0a220ec00e062e2b + v_result = 2fb71f22966ecb4d | a95ead99e63cc96e + r_arg1 = 46c71209e5ec80d3 + r_arg2 = 316aa03d753a8723 + r_arg3 = c3e3378d1fae3b8e + r_result = 0000000000000000 +insn vpkg: + v_arg1 = a0173195b9aef7c8 | bc7f1a86b4aed821 + v_arg2 = 87c1ee6717cc2d7f | cb8173a9741d00d9 + v_arg3 = 9434283803647081 | f6ddff4063d275ec + v_result = b9aef7c8b4aed821 | 17cc2d7f741d00d9 + r_arg1 = faca1bb070062efa + r_arg2 = 38bf12bf6a9c559f + r_arg3 = f3ef63e478a6d51b + r_result = 0000000000000000 +insn vpkg: + v_arg1 = d49fd7f968efd336 | ad173ce49d89ecb9 + v_arg2 = 13352663b975ed23 | 44ddbf5225e7a6b8 + v_arg3 = 8482adceaf80bcdb | dce3c8f04d0e6ccb + v_result = 68efd3369d89ecb9 | b975ed2325e7a6b8 + r_arg1 = cbca22eb59c79b69 + r_arg2 = 725ab01f908ec3e7 + r_arg3 = 91b87e435823e7b3 + r_result = 0000000000000000 +insn vpkg: + v_arg1 = 026c51abd75367fb | f6e3e9c2de97a292 + v_arg2 = 7bfd34eed36f2eaf | 049b843ab3ee62a5 + v_arg3 = cbec63b0a55229a5 | 902f5016b3c8c57c + v_result = d75367fbde97a292 | d36f2eafb3ee62a5 + r_arg1 = dbcfdf90d94f4968 + r_arg2 = 59e07802d4adfaee + r_arg3 = 30428dda2401fdb6 + r_result = 0000000000000000 +insn vpkg: + v_arg1 = d36d1ea843617f04 | 9874e6ec6ddc6a45 + v_arg2 = d706e564d0fec72b | f9c35309c27431d6 + v_arg3 = ee5a61937cdb9904 | eb46f436e17f0ad3 + v_result = 43617f046ddc6a45 | d0fec72bc27431d6 + r_arg1 = 57707fb38c2b9058 + r_arg2 = 2d489d0949c4b683 + r_arg3 = e4a08a9b2509fd24 + r_result = 0000000000000000 +insn vpkg: + v_arg1 = fc21352c540eba5c | 5ca42e2c658e4c4d + v_arg2 = c549f9dc0252e440 | 573075e5966725e1 + v_arg3 = 7643366b3287c73d | 90fc49d14bdd587f + v_result = 540eba5c658e4c4d | 0252e440966725e1 + r_arg1 = 2d91666636185f7b + r_arg2 = b5924a96e88d0f16 + r_arg3 = 0bb125f349b4e25a + r_result = 0000000000000000 +insn vperm: + v_arg1 = f455c272d37f50eb | 905fb40ac8cda3c1 + v_arg2 = 2a90e9ed614bc8f1 | 5846a631df242777 + v_arg3 = b56ba52ae8f2ff6f | a335d8284a7b24d0 + v_result = 4b0a7fb490e977c1 | 724b5890b431d32a + r_arg1 = d524ee7a7fbefcaf + r_arg2 = fd915d8450702d74 + r_arg3 = 06e6828ee7e57dd2 + r_result = 0000000000000000 +insn vperm: + v_arg1 = b9e3e57171c5cd3a | c75c1f8b3c68e214 + v_arg2 = ef31a26a49368b61 | fcbcda506e39b62b + v_arg3 = 7fa46780aaa5e859 | 90a0e1f8dda2fa74 + v_result = 2b713ab91fc5c7bc | efb9e3fc39e5da49 + r_arg1 = 09eb263bb674c032 + r_arg2 = 17a12cf186411388 + r_arg3 = fef9fe1578b133e5 + r_result = 0000000000000000 +insn vperm: + v_arg1 = 8f72769f879ed32c | 9de38df4cf9d52db + v_arg2 = c5d049253d90dd92 | c952fc62fe1da72a + v_arg3 = f190ec9b25d93b19 | ca7c193e6a073934 + v_result = d0c5cf629e526252 | 8dfe52a78d2c523d + r_arg1 = 8d3394379201dc5e + r_arg2 = da7044f7b604561b + r_arg3 = a0b5ebf25f19c28b + r_result = 0000000000000000 +insn vperm: + v_arg1 = c13bc4b0d139ddc5 | 71875187b3d8d386 + v_arg2 = e220f5aea6c1c123 | 8d9baa04edf8e403 + v_arg3 = 2e5c1be76f318aea | 8a566cf37c8cd9ba + v_result = d3ed04c586205151 | 51c1b3aeedb39baa + r_arg1 = e999f3f6ed58186d + r_arg2 = a6b7266cf2abe394 + r_arg3 = e2b44f09a3cdfc18 + r_result = 0000000000000000 +insn vperm: + v_arg1 = 5fc1525733f1f8e5 | 2aecb54303729724 + v_arg2 = c3a0791295e05410 | 18b3fb1200602d5f + v_arg3 = 1d850ecec382fae4 | 8dc7bcd08305264d + v_result = 60f197975752fb33 | 72e500c357f1f872 + r_arg1 = 2ac8f6c188598f34 + r_arg2 = 1e0009a8efd5bdb7 + r_arg3 = bc1aa97fb0ea8bff + r_result = 0000000000000000 +insn vperm: + v_arg1 = ff979903750f880c | f381b9a77d71eb22 + v_arg2 = e860189f7d748475 | 03073a672318dac9 + v_arg3 = 2e96d878438d09be | d739a10998ef8392 + v_result = eb840303037181da | 7507978103220318 + r_arg1 = a537045ecb9674eb + r_arg2 = ed619c3fcb8fbc68 + r_arg3 = f05ead751abbac91 + r_result = 0000000000000000 +insn vperm: + v_arg1 = 7d1ccaa1068b0a17 | ff45d26e474def0a + v_arg2 = 9bbc4e9efb30da4a | 6d13a99a27d29866 + v_arg3 = 13e63f8bb5c24a8d | 73a228143739294b + v_result = 9e0a666e30cad24d | 9ecafffb4a13456e + r_arg1 = b5eefbd1830ad1e2 + r_arg2 = 833ec1c1ca165068 + r_arg3 = c30003cc5a7af5bd + r_result = 0000000000000000 +insn vperm: + v_arg1 = bc408a5fbdcbcc00 | 4684ad53aba85947 + v_arg2 = aa1f8f178fb43126 | b91e3fc282ed28bc + v_arg3 = 875d83ea47fd2584 | 3046956203fee61a + v_result = 00ed5fad00edcbbd | aaccb48a5f28cc3f + r_arg1 = 7840ee1ba2e1434b + r_arg2 = d609537f14923d15 + r_arg3 = c2520de2900e10d0 + r_result = 0000000000000000 +insn vperm: + v_arg1 = 633fb4659461b7a0 | 469aeacddb1336de + v_arg2 = 29c0008f60517dff | 51fe6b311436236d + v_arg3 = 0a2e16784c4b98b5 | 667722238547df3d + v_result = ea367d51dbcd5151 | b7ffb46561a06d36 + r_arg1 = 9791e8fc0336c0f5 + r_arg2 = 2204e14879da5d2d + r_arg3 = 7f339f5240cd7e35 + r_result = 0000000000000000 +insn vperm: + v_arg1 = a1641b9d6ccf076e | c4aee2d2afcea935 + v_arg2 = 326740cbfdc486e6 | 67d9cf3bddaabafb + v_arg3 = a39c61d4fda5f9cd | b057be06eecc4f52 + v_result = 9ddd64fdaacfd9ce | 32e6ba07a9af3540 + r_arg1 = fb10a7b423cf520e + r_arg2 = a9fc72262f35628a + r_arg3 = 52cdc5b6153a5535 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = eac6466bcd440d40 | 8a7662966287abcf + v_arg2 = a627228d17f9aace | afe006efc8306f85 + v_arg3 = 9eb8861d39b3b2db | b093cff5d1b24513 + v_result = eac6466bcd440d40 | a627228d17f9aace + r_arg1 = 997c61bceae1dadf + r_arg2 = 740e40248f1592e5 + r_arg3 = 1a5d8166a2c702b6 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = b70d3273a45ff408 | 27f86f4c5919ca0c + v_arg2 = ea24715448c89f45 | 271560db6462dd87 + v_arg3 = 4d2019af45890408 | ce28f0daeb4d6a1a + v_result = b70d3273a45ff408 | ea24715448c89f45 + r_arg1 = 28e1839061d1ce92 + r_arg2 = 11647d0adbdd8a96 + r_arg3 = f9e98b391c9309fe + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 4b2c145903ea7a97 | b24500e2dc4decec + v_arg2 = aa4dab1ecfba3037 | d005a1cba644769d + v_arg3 = c7c1e7e28e6bc65e | fa20b45fdcdeba9d + v_result = 4b2c145903ea7a97 | aa4dab1ecfba3037 + r_arg1 = e65b6e687aeffcee + r_arg2 = 53f7111efc9bfb51 + r_arg3 = 1b0a1042222bc170 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 6926157be59fb35c | 883fc7c8db9b09cc + v_arg2 = 9a21c72852c3fcb1 | 738dc788a909403e + v_arg3 = ac94b0d0638a2384 | 665462a9ec554731 + v_result = 6926157be59fb35c | 9a21c72852c3fcb1 + r_arg1 = 58d039f8cb3b4517 + r_arg2 = 164e5ae33dcd70e9 + r_arg3 = 71a37394764c194d + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 20cc15b7e8e5ca24 | 0a53eaa8ace8f425 + v_arg2 = 306cf0ac9c083a9a | 5d97c19c6ed39884 + v_arg3 = e063ed0fbcc7607f | 4e2bb81bc70efa89 + v_result = 20cc15b7e8e5ca24 | 306cf0ac9c083a9a + r_arg1 = 07b9733653236451 + r_arg2 = f93cecdc111e070f + r_arg3 = 6fa610fdc29d5673 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 807c6a2a1192c1d9 | 603ec22dc8481352 + v_arg2 = 6c0948a15e99787b | 23dd390b9d72f0e1 + v_arg3 = 4c838b71f66e9471 | b158a91741965237 + v_result = 807c6a2a1192c1d9 | 6c0948a15e99787b + r_arg1 = 44d9de133542a5bd + r_arg2 = 23a45049d3293412 + r_arg3 = d2d4f5cc5478d320 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 62e39eed8ca92c46 | 39caa3c092bc234a + v_arg2 = 91a1a67dee375837 | 60a34b1a422391e9 + v_arg3 = a09aaeca95fc6e5c | 159e1fbf13662368 + v_result = 62e39eed8ca92c46 | 91a1a67dee375837 + r_arg1 = e502353f7921ae19 + r_arg2 = ff37c5e78133839f + r_arg3 = 5d7ca78de3a0c0ad + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 25ba35d86a1cfad1 | 8990954410f3f660 + v_arg2 = ea6959f40b0d52d1 | 727f4c0a92525a0e + v_arg3 = 14596fa902d8f4df | 478ebaaf9da559ab + v_result = 25ba35d86a1cfad1 | ea6959f40b0d52d1 + r_arg1 = 06d5e7e8cff83a83 + r_arg2 = 003302b381f45381 + r_arg3 = 973ae4ca490be456 + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = 6c8b654262892d3e | 4bb714e0b00c3609 + v_arg2 = 87e7e3b89779752b | 421385dca5577f5e + v_arg3 = 23429f1b4b1c3ff6 | 194690c3a3e9b3a9 + v_result = 6c8b654262892d3e | 87e7e3b89779752b + r_arg1 = c981da7a4c6cd935 + r_arg2 = 5e25f2a55e4d9c61 + r_arg3 = 8fb95bcb47985cef + r_result = 0000000000000000 +insn vpdi0: + v_arg1 = e26bdcbe91009d71 | 3db2d4b405512095 + v_arg2 = fdacbf3a5cc327c4 | f9d0f50e393b4c45 + v_arg3 = 5062836ee64b40bc | 2332ecd510f589ec + v_result = e26bdcbe91009d71 | fdacbf3a5cc327c4 + r_arg1 = 18822a5e2b51b349 + r_arg2 = d8a677788811aa86 + r_arg3 = 9970765644d85aaf + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = f6c07ede3ababa2a | a7047fa188fc49f3 + v_arg2 = 2a1a1d66c8e3e178 | ccb4135b7672e050 + v_arg3 = e21597ea6e1a7e2b | 84ce0f7eb77b879b + v_result = f6c07ede3ababa2a | ccb4135b7672e050 + r_arg1 = 5e62e9be8d684374 + r_arg2 = 7120295f17c0e094 + r_arg3 = 0f66126e0ec8e8e8 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = a0fb25f288e147c9 | 15fe760458f45d6f + v_arg2 = ef1ea169b23ef443 | b20b8b7da5a0f3e6 + v_arg3 = a7c84c99652bd6d9 | 9e60f3d40ed9703a + v_result = a0fb25f288e147c9 | b20b8b7da5a0f3e6 + r_arg1 = 527add3e3a201ccd + r_arg2 = 338815d08845764f + r_arg3 = 12f042169993a3cb + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = 1a5d60c8474d200a | 197e8c7afa8edb76 + v_arg2 = f5f4286e146748fd | 2931fdedf858910f + v_arg3 = b5b1cafff1cc3bbb | dec00329f1dfdc6e + v_result = 1a5d60c8474d200a | 2931fdedf858910f + r_arg1 = adb145c35f57a787 + r_arg2 = ef247e3c7fbe3c58 + r_arg3 = 4770100dbc548127 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = a9b5356caf44f6c9 | 0ab0cf9c1b4fdb50 + v_arg2 = 6ae9845bcfe1181d | f64cc2a046d7de30 + v_arg3 = 2597aee0a0ba75e5 | 7213e4d06686fbb5 + v_result = a9b5356caf44f6c9 | f64cc2a046d7de30 + r_arg1 = f03a952f4e19e4b1 + r_arg2 = fc45a0d2853355ed + r_arg3 = 9a173b92f8d08b29 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = 521fe0e81a380fbe | c8cf40c24aa8cae3 + v_arg2 = c1133b966adbb779 | e215a7cacccbd0cb + v_arg3 = d78fcd0025e3e246 | 118a30da53b85131 + v_result = 521fe0e81a380fbe | e215a7cacccbd0cb + r_arg1 = 1f583521425f25fb + r_arg2 = f40c6842c85cfeac + r_arg3 = ffa3fb21313ea41c + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = a6c59204ca8b0741 | 77e497c3bfb72975 + v_arg2 = 76194dc5d4f14f02 | 7e8eb09ded11f842 + v_arg3 = 32bbf1dd191e386f | b82637d44a0d785d + v_result = a6c59204ca8b0741 | 7e8eb09ded11f842 + r_arg1 = 891c47b819d0d772 + r_arg2 = 7b283e77de5e454f + r_arg3 = 2c20b93372024129 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = 77a03306a54d9105 | 408400b2180c5169 + v_arg2 = c8f0eb881ef09e8b | e0cbd609f4713a94 + v_arg3 = e10c9875bcf3414b | 6776bd893f8be2d4 + v_result = 77a03306a54d9105 | e0cbd609f4713a94 + r_arg1 = 7e245f4f18823a41 + r_arg2 = f995bc5b838cd36f + r_arg3 = 61a9d900ae6c2f16 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = a0362171f8fb37df | 1495e1a1176032ff + v_arg2 = 7d9a413f4290b781 | 64acca7ccd62901d + v_arg3 = 9700b805b1599de6 | e956bfc44c649510 + v_result = a0362171f8fb37df | 64acca7ccd62901d + r_arg1 = 185c4941abb82471 + r_arg2 = 5b5d75955629a344 + r_arg3 = 2127713e7a7c520a + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = c25cefc73840177f | 69089260655d1017 + v_arg2 = a2e82ecae03ac7b3 | 6da0b1a3d0cbcc59 + v_arg3 = cc637ec6c671852a | 8ab02e0e74baed26 + v_result = c25cefc73840177f | 6da0b1a3d0cbcc59 + r_arg1 = f3bfc7a423a3c2a9 + r_arg2 = d659b04ca123c962 + r_arg3 = f70f0fe1d59f6045 + r_result = 0000000000000000 +insn vpdi1: + v_arg1 = 03f4284abdb6a534 | fb9e233d525b46ed + v_arg2 = 49370742fcc3ce0b | 2263e62677bf549f + v_arg3 = 7f100ab1aa4e839c | df3db26a5e5d5e8d + v_result = 03f4284abdb6a534 | 2263e62677bf549f + r_arg1 = f5155010772458ee + r_arg2 = a4ef2ae40fd92d7c + r_arg3 = 332777dce272aaeb + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = ceaf0ab686a56cab | 8ca61bc4941f04dd + v_arg2 = 4b3658c3c22e6351 | 32bfbc6e243fe5e9 + v_arg3 = f3af363ab5af3c21 | 8243691f168a30d8 + v_result = 8ca61bc4941f04dd | 4b3658c3c22e6351 + r_arg1 = 08b6d3590487fd62 + r_arg2 = c6d4d8bf74d44d23 + r_arg3 = ab4063dea87dd4b9 + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 95cb4c07f8c1cdaf | a5bb347e049e111f + v_arg2 = 049da424426c71ed | 914d3a60ddfa5089 + v_arg3 = 72784d17a5c127be | d457a76dd1ac4276 + v_result = a5bb347e049e111f | 049da424426c71ed + r_arg1 = dc44734f4e486006 + r_arg2 = c1caa3fc8990ff86 + r_arg3 = 7bfb4215d9f799cd + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 92d4d8389feebee8 | 548920b565b7898a + v_arg2 = 1af520bc351efda4 | 3933de21100e40f3 + v_arg3 = 0eedd4f95ce15352 | ba1bb555a61dc877 + v_result = 548920b565b7898a | 1af520bc351efda4 + r_arg1 = a6734983bdd0867b + r_arg2 = 62622b39ad332e32 + r_arg3 = c586faec89878960 + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 83659200ecfe8d9f | ed88482d1dfaa054 + v_arg2 = 36557c1eb750de59 | eae65bd34fc7f379 + v_arg3 = 5ba24551a357255c | 6000925456e40d49 + v_result = ed88482d1dfaa054 | 36557c1eb750de59 + r_arg1 = e4c3260461378abb + r_arg2 = 7bb98553a65299d2 + r_arg3 = 725fa7cff200cb8e + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 6ae61195f6709c77 | cabe88ebfa665fce + v_arg2 = c9229bdb0b3e83cc | ebe85b56155dfe08 + v_arg3 = 37f7cf0beb1a18ba | fa03b52705773275 + v_result = cabe88ebfa665fce | c9229bdb0b3e83cc + r_arg1 = 17434e1caf025ce4 + r_arg2 = a43dfe245eb297ef + r_arg3 = ef0f5ae43722dc0b + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 534e616b3a312334 | 0b80f5f1ef25622b + v_arg2 = cacd57455b11b25d | c8893e0780b90aef + v_arg3 = 83db195407917c66 | 7e72c987fe79ee65 + v_result = 0b80f5f1ef25622b | cacd57455b11b25d + r_arg1 = 884e3f1642e583ec + r_arg2 = fb68d642a703d6b0 + r_arg3 = f2efdbd21f5e4eee + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 0fe2c8f55c5ef176 | 573098fed551a139 + v_arg2 = 73973f2976a143c8 | 12a9da8215309997 + v_arg3 = e789fd56f34e383a | 6ca770ed747c4d20 + v_result = 573098fed551a139 | 73973f2976a143c8 + r_arg1 = 045068fa9c81dc6c + r_arg2 = e48306c5f9a61899 + r_arg3 = 34e5687dd7928a69 + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = f2f27e61e4fe2c7d | 99ff30512cb12425 + v_arg2 = 084e58939033eae8 | 23733a628044c24b + v_arg3 = 934d4df891d489ac | 88cb014d3dbf720a + v_result = 99ff30512cb12425 | 084e58939033eae8 + r_arg1 = a181f34ee3265958 + r_arg2 = ca63fb002f67f54e + r_arg3 = 352674c6b1c78f8d + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = 99a2735f02cb0de5 | c4aaf465d77bce39 + v_arg2 = 9010e08c063beb77 | d7225ffe5269f1f0 + v_arg3 = f93f91a26751c191 | 9b934bdd96ef55a8 + v_result = c4aaf465d77bce39 | 9010e08c063beb77 + r_arg1 = 77a77dd6a491c3c3 + r_arg2 = dd2d59464e419d50 + r_arg3 = fbf4694ee7f9b209 + r_result = 0000000000000000 +insn vpdi4: + v_arg1 = a79d0ed94be9a56a | 903f50b5e41314a0 + v_arg2 = 9b0607de181ae4cc | 55be022dc2bca9cc + v_arg3 = 9405c7f663630adc | 350451cee2e98659 + v_result = 903f50b5e41314a0 | 9b0607de181ae4cc + r_arg1 = 68d7d85394ad799e + r_arg2 = d314baa53f2093bd + r_arg3 = d35f673359cd5cea + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 83e2e9bb7aab9ba4 | 3cd8a47842c8c31f + v_arg2 = fb28b5cdaee0879a | c4de51016ecc4241 + v_arg3 = a594239798d6215f | 6e310c106b74e81c + v_result = 3cd8a47842c8c31f | c4de51016ecc4241 + r_arg1 = d933d0464b543078 + r_arg2 = a8186dac90997312 + r_arg3 = 100704cf4b5bd05b + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 1c7996ab3154eccb | 4b5d08648a9cbedc + v_arg2 = 8bfe47de14095eb5 | 1767ae8e1753ac91 + v_arg3 = f1eecde400621c87 | a1fa2d11200a774f + v_result = 4b5d08648a9cbedc | 1767ae8e1753ac91 + r_arg1 = 78abe4ac080db23f + r_arg2 = 5fc7382737b2aeeb + r_arg3 = c8d70b7f29e4e364 + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = a63d5ed0b6d2ab72 | 48450b6db7fbbd1a + v_arg2 = eb5c5293bf4286cf | c34974a369fd2b9b + v_arg3 = 85e3a7bc38702423 | 31cdd87d558e046c + v_result = 48450b6db7fbbd1a | c34974a369fd2b9b + r_arg1 = f5bf0ac170ce9ffc + r_arg2 = bfff17e1509f49c1 + r_arg3 = 9aca3e58439cc2ae + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 5b93fd8eb683c04e | 82557085ee8210f9 + v_arg2 = 42245f2b06247536 | 8447b28db11e199b + v_arg3 = 73d3053b47d43c1c | 44686bfe8716f4cc + v_result = 82557085ee8210f9 | 8447b28db11e199b + r_arg1 = c93a6cc04fba2f99 + r_arg2 = 17a9fb5fdb81a2a9 + r_arg3 = 6ba814f29260b03c + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 3b30674606f2a9ef | d15df15d38b85b39 + v_arg2 = fc06ae64eaf6b596 | 1cafeedaa57fa8ec + v_arg3 = 936973795793f93c | 8b9435fb16a10667 + v_result = d15df15d38b85b39 | 1cafeedaa57fa8ec + r_arg1 = f2f72da156e3ee9c + r_arg2 = fb7d8caa7f272c1a + r_arg3 = 25c87c20727fc532 + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = cdd687195e993c84 | 4f00fc2143d758f6 + v_arg2 = 8b42f53bcf6ea7bc | 131ce41320109dc8 + v_arg3 = 435f73507b9d49ea | f9e9405c0ae00a91 + v_result = 4f00fc2143d758f6 | 131ce41320109dc8 + r_arg1 = b49e25d8dc0780ec + r_arg2 = 04c3e8044ad02fa6 + r_arg3 = 77ce98b46673b191 + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = dd15fca41da0639a | 206c793f2582996c + v_arg2 = 27631faa416f414f | 793a457fe3b51705 + v_arg3 = 27403c1668922deb | 888f0843cff0abbe + v_result = 206c793f2582996c | 793a457fe3b51705 + r_arg1 = 5b66a11b9f555b8a + r_arg2 = 950f62b06fe689be + r_arg3 = 986d833ed8a778f7 + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 3c0cdbc4089bdfdb | 2c1c831f1a8f44b3 + v_arg2 = 8e030d67b0cbd098 | a18179e556fd46d8 + v_arg3 = eb1f7d5d3d807f21 | f8fa42d3fa1d273d + v_result = 2c1c831f1a8f44b3 | a18179e556fd46d8 + r_arg1 = f5d3251b80299058 + r_arg2 = 910344ae07c27071 + r_arg3 = 05250dcdd7323561 + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = 842870520c4f06d2 | e09c2aea42bdd582 + v_arg2 = c48d58aa3500b839 | e4f65e4946e43595 + v_arg3 = fd6418b83ca1ad4e | 8fac97eb029f12fe + v_result = e09c2aea42bdd582 | e4f65e4946e43595 + r_arg1 = 19782b474bca83d4 + r_arg2 = 270f8f7bd26d2e2c + r_arg3 = 3f047aabd899d8eb + r_result = 0000000000000000 +insn vpdi5: + v_arg1 = d2e3fde6f86c85a4 | f2433846647de0ef + v_arg2 = d4f40ee74cfe2ff8 | 64f008aca697826b + v_arg3 = 547ee9788e207cd1 | dbf567ea085e174f + v_result = f2433846647de0ef | 64f008aca697826b + r_arg1 = a4b5e28f6d31afdb + r_arg2 = 8733b6d3f45ce47a + r_arg3 = 8e6747237690e78d + r_result = 0000000000000000 +insn vsegb: + v_arg1 = 8a857a97445220d7 | 1af9ea16aeaccd2b + v_arg2 = 8e80718e98de0774 | c6d07fcf4f2f212b + v_arg3 = 2cb07d6a04d4c665 | 6cb4876b90b1b799 + v_result = ffffffffffffffd7 | 000000000000002b + r_arg1 = 7678f01ebcc4646a + r_arg2 = abb96771b83248c4 + r_arg3 = c1b9e53c32b841df + r_result = 0000000000000000 +insn vsegb: + v_arg1 = 17e554b8cdcf6e0e | daf2b33d73559b49 + v_arg2 = 4880bcd0a3aa62ed | f8c685f0c0731d00 + v_arg3 = c7c7dc99d1023ee8 | 9b16040846190826 + v_result = 000000000000000e | 0000000000000049 + r_arg1 = 3afe311e33158957 + r_arg2 = 0ffe43cc50816811 + r_arg3 = ec327d7e3460d7d4 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = a8272f9b97dd9eca | 3770fd5bed729ef7 + v_arg2 = 9e17de5c9c1a7cff | ea914e8ade995737 + v_arg3 = 2fe14011521e2810 | 4655de1abb0978dd + v_result = ffffffffffffffca | fffffffffffffff7 + r_arg1 = 1c927676b3a75a1b + r_arg2 = 7929a1db948766c5 + r_arg3 = 2a98abab08477281 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = f57ea4508a673528 | 7e83e88df9ab4141 + v_arg2 = 32f23d1c18546565 | 553e4617b50346f7 + v_arg3 = f026dc98c6892136 | 9279ce7626a08902 + v_result = 0000000000000028 | 0000000000000041 + r_arg1 = 914c478ec4a72b8a + r_arg2 = b3f150d0c0f43a64 + r_arg3 = 59ff4486625771d6 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = f9e904653604cea8 | 01ca0a30de14c554 + v_arg2 = 6d0f75fbd2aac4b9 | 77e7cfcf3705b608 + v_arg3 = de9196751752de0e | a9190131236c93f9 + v_result = ffffffffffffffa8 | 0000000000000054 + r_arg1 = 13d1a20853b52597 + r_arg2 = 4d5a52df37a1734f + r_arg3 = e18b108edc698862 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = b6f914a690b9d9e3 | d8322d9d06f10138 + v_arg2 = 3d7617a16b5e9631 | d5740069f99d8a8f + v_arg3 = d5a7ce2c90f7e56c | 7a19db5b78278503 + v_result = ffffffffffffffe3 | 0000000000000038 + r_arg1 = e218ba86739c0513 + r_arg2 = 5c77a2f74258f684 + r_arg3 = 6e2b91c2b4068312 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = f588cfddb3ba5e52 | a1b415ecc4742193 + v_arg2 = d6026b342b60ed63 | f85c68d8f9387ace + v_arg3 = 753c153ea52456ff | 7d6bb6c6cc7ca5fe + v_result = 0000000000000052 | ffffffffffffff93 + r_arg1 = c521b9691d14e06d + r_arg2 = 3e27ef86d291be60 + r_arg3 = b25ebb5e8f2301f1 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = 04822891a127b80c | 411a38b40d7c686b + v_arg2 = 71172f17be0db200 | 3163c90e5b72d5e7 + v_arg3 = e234f7ecaf72a518 | 6cd1a1be6fc24c28 + v_result = 000000000000000c | 000000000000006b + r_arg1 = c8bf7f8ff085e172 + r_arg2 = 54db60373a329c5f + r_arg3 = 25f1ba9a39e33ae8 + r_result = 0000000000000000 +insn vsegb: + v_arg1 = 769ec6ca00d25a87 | a1ba84c84057eee2 + v_arg2 = 116c57adf9f0649b | 575bdfbc27d44199 + v_arg3 = 8b3eb3f3ae275e62 | 0b9821d015beabdb + v_result = ffffffffffffff87 | ffffffffffffffe2 + r_arg1 = fc4e6213f2c50a0d + r_arg2 = c74d4fb6f74df5da + r_arg3 = c5beb0706357ba7d + r_result = 0000000000000000 +insn vsegb: + v_arg1 = e724c6cadef68d54 | 72381df9df7f63fb + v_arg2 = 39c1cb169383d862 | 84e6170e0d967700 + v_arg3 = e099fe5006fbe0a9 | e25df4879b638a51 + v_result = 0000000000000054 | fffffffffffffffb + r_arg1 = 3b7ced0f4dd8f007 + r_arg2 = 44480e6969e487c6 + r_arg3 = d66c755663402496 + r_result = 0000000000000000 +insn vsegh: + v_arg1 = b6a77dd46eff31e6 | ea471dd9545fca52 + v_arg2 = b8a92cefededf8e1 | dc315971225d0957 + v_arg3 = 1bd2c5fc42d02396 | fecbca29c2940460 + v_result = 00000000000031e6 | ffffffffffffca52 + r_arg1 = e202a15c13ad80c7 + r_arg2 = c166a63897a7257a + r_arg3 = a33456fef8caf036 + r_result = 0000000000000000 +insn vsegh: + v_arg1 = c9cb34e7c948784b | 85665375ad0e40e7 + v_arg2 = 5e409014cbc484c5 | 46b9bf4fa2fd1cb8 + v_arg3 = f882e8afd5777370 | b4590b7defdf4d3d + v_result = 000000000000784b | 00000000000040e7 + r_arg1 = 956ab84ffbe6bd11 + r_arg2 = 36cb9344efb27668 + r_arg3 = 3c99d71c05512e3e + r_result = 0000000000000000 +insn vsegh: + v_arg1 = 4effeb82aed7aff0 | c6a505196110b3d2 + v_arg2 = c4f3426019ccd495 | 31095bd0ac372ed9 + v_arg3 = 7e1300a0d47134dc | 5f0f9586f2426c3b + v_result = ffffffffffffaff0 | ffffffffffffb3d2 + r_arg1 = ffcadd7c22907fc9 + r_arg2 = 65ee89b20452bae1 + r_arg3 = 372e711e521e422c + r_result = 0000000000000000 +insn vsegh: + v_arg1 = 754218604221f660 | f460af0f091bac0e + v_arg2 = 093e846aa8b59579 | 5178f699097bd2cf + v_arg3 = b47b1a42beaa9c9c | 1d407b47bce9028b + v_result = fffffffffffff660 | ffffffffffffac0e + r_arg1 = 9086f576cce536b0 + r_arg2 = 934f336050c086d4 + r_arg3 = 705255f44f29a6dd + r_result = 0000000000000000 +insn vsegh: + v_arg1 = 37e0653cd2cb0303 | de02c25e28cf0631 + v_arg2 = 90684e49efdf88f6 | 61eecc90e6a670cd + v_arg3 = 6dfe7a07353d7c52 | 9650c78028ec01fc + v_result = 0000000000000303 | 0000000000000631 + r_arg1 = 3e10db8b2210a624 + r_arg2 = 4d40f0acf0e4848e + r_arg3 = caf527c9d0d7ac4d + r_result = 0000000000000000 +insn vsegh: + v_arg1 = 1235768c8d65e3e2 | 98c2668ee57bb531 + v_arg2 = c3470c4fcb1747af | df9e529596c306e5 + v_arg3 = feee591fc336f83d | b66e396eb41476bc + v_result = ffffffffffffe3e2 | ffffffffffffb531 + r_arg1 = 45aa1c8af2e8aae3 + r_arg2 = 25a095336b12357a + r_arg3 = ec53c5c6d2bc3954 + r_result = 0000000000000000 +insn vsegh: + v_arg1 = cb68a1494b30ba60 | 3c683961ccdd811f + v_arg2 = d40164d03f590024 | d3cbf14852cceac4 + v_arg3 = 026da838964a4bf8 | 6f59078e45964114 + v_result = ffffffffffffba60 | ffffffffffff811f + r_arg1 = e721bf8072b1f1c7 + r_arg2 = 73992e8f6cceafe1 + r_arg3 = 05b7ffd436598c6a + r_result = 0000000000000000 +insn vsegh: + v_arg1 = 2c2fb4a449d87e00 | ab070f9991e0c8ee + v_arg2 = 77c7eedb358f3874 | 8986c9c8f9688679 + v_arg3 = 1e28cc3e459f8541 | 791d9c59e7d4d92e + v_result = 0000000000007e00 | ffffffffffffc8ee + r_arg1 = 2d920075fde1c489 + r_arg2 = 1567bd16838a5fa9 + r_arg3 = 88385c5982def662 + r_result = 0000000000000000 +insn vsegh: + v_arg1 = c490b3d0eb38c125 | 49c2b0b7cd5f402c + v_arg2 = aa9bfafe3c4f891d | 526d6f70d1ad1b2d + v_arg3 = b71c611b89894cae | 12d659078b2209d1 + v_result = ffffffffffffc125 | 000000000000402c + r_arg1 = a4271032d5d7bf81 + r_arg2 = 3013f9a0e965c919 + r_arg3 = f17edcf9a3e79f31 + r_result = 0000000000000000 +insn vsegh: + v_arg1 = aa9c98be7a1c65cb | c58a9eb9c0dfb4c6 + v_arg2 = 6e0a4f0449a065ba | 486daf9b44de80eb + v_arg3 = be53f87705499f78 | be6a584fc87db621 + v_result = 00000000000065cb | ffffffffffffb4c6 + r_arg1 = 22d9d8fde0a49463 + r_arg2 = ed33114039ec4492 + r_arg3 = 7f7cb155ae4148a7 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 3b3512dae4f96552 | cfddccda0e58c3c6 + v_arg2 = 8bf1e7b977b4d2c3 | 087f4c60a42de058 + v_arg3 = 65a6d97700ce8f33 | 095224249b549762 + v_result = ffffffffe4f96552 | 000000000e58c3c6 + r_arg1 = 802fb4596cc5cc02 + r_arg2 = 3dab680838dbbf55 + r_arg3 = f93505ce9aa50433 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = d7c847d27fb59333 | e188685582eca417 + v_arg2 = 513ab5a3c7ae2d4f | 766dbb55e8798079 + v_arg3 = e87cc28026770593 | 415182782741fbb5 + v_result = 000000007fb59333 | ffffffff82eca417 + r_arg1 = 5efc39c9ece6850f + r_arg2 = 976d57c88fdc7f42 + r_arg3 = 6b7ab842087affa2 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = a912934ec66456c7 | f8649320cface53e + v_arg2 = 529e5fc9e15ce8d3 | 7d8cec4f6e0f7773 + v_arg3 = 4688a6f44bce8027 | 3d392cfb76cf87d8 + v_result = ffffffffc66456c7 | ffffffffcface53e + r_arg1 = e223ef8db99f36d9 + r_arg2 = b53aefcf8d45df96 + r_arg3 = e6a91fcbfc9638df + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 5ddd47b71b066805 | 581b25b34a582821 + v_arg2 = 2964056fd2fc4ce3 | cd82021fb86b7445 + v_arg3 = 058d6ff2294dd41f | 19ab92db3735f6e9 + v_result = 000000001b066805 | 000000004a582821 + r_arg1 = 7a551862d239670e + r_arg2 = 5b61b5a7e6dd0fab + r_arg3 = 436fc786a2fc46b2 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = e8c26bf3844d9f42 | 4ce26ac2b21ee5c2 + v_arg2 = 371ff8d7ccf938ee | 9c0017542ff77d8e + v_arg3 = f21cbd191d1bed09 | f7d698837f18d822 + v_result = ffffffff844d9f42 | ffffffffb21ee5c2 + r_arg1 = 96d068449d687a77 + r_arg2 = 107e64db7796d6ba + r_arg3 = e18530480b9e1784 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 44e87d266f54a1f2 | e33fe8fde9582b04 + v_arg2 = 61728400eaaee105 | 6688fafee3c9ab4c + v_arg3 = df53a645eece8a8e | c0365b5f894c559d + v_result = 000000006f54a1f2 | ffffffffe9582b04 + r_arg1 = 6f21cb2ea41166bd + r_arg2 = e33bafb30053519b + r_arg3 = 63759369ee1bad18 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 32c231716f68ae65 | b5c317d5b9516063 + v_arg2 = d4cea868ea209093 | ae27f1684968ef9a + v_arg3 = 649e744e87290338 | e255ec967692e810 + v_result = 000000006f68ae65 | ffffffffb9516063 + r_arg1 = c3e123d759047729 + r_arg2 = 2812fdf4e9a1b381 + r_arg3 = 74549d7c6880e052 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = f7d32fb5fdc25a8a | 9dd027399100fdbf + v_arg2 = c231d9ccf1c66825 | ba3977dbfd86d06f + v_arg3 = a0796bceb8dd042e | 118c14cd0e5a2490 + v_result = fffffffffdc25a8a | ffffffff9100fdbf + r_arg1 = 977a0776d3c1105f + r_arg2 = 39072ba4fe8003c1 + r_arg3 = 83883313bd0920f2 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 206cd84f384951ae | 7d52bf5345ca5310 + v_arg2 = 23e7c3e64b441d22 | 5b2bff607fc52c64 + v_arg3 = f52a81dafa4b50f5 | 07c20fe97e807350 + v_result = 00000000384951ae | 0000000045ca5310 + r_arg1 = f5e1867d90366921 + r_arg2 = 36704ec3331be18b + r_arg3 = 88822c7e15e03058 + r_result = 0000000000000000 +insn vsegf: + v_arg1 = 3f6b02dca653133b | fe88b94ed2434a31 + v_arg2 = 754c092c292abf92 | a433b07df675f36d + v_arg3 = d08925c7293f7f2f | 442a51cc1911d261 + v_result = ffffffffa653133b | ffffffffd2434a31 + r_arg1 = ac5ce360327d5210 + r_arg2 = c6af6f11618a42ae + r_arg3 = bd831a8b40dbed41 + r_result = 0000000000000000 +insn vste: + v_arg1 = abfcb8f5f163b67c | 4ebce81218ec1d98 + v_arg2 = 7d86009662b86eda | af1828f6f053f09e + v_arg3 = 5fbbf9e548b5c15e | cf07451517059672 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 143c574e42a1ee6c + r_arg2 = d5f54ecd08962f57 + r_arg3 = 665a034673400586 + r_result = 0000000000000000 +insn vste: + v_arg1 = 445afcf2abeaa756 | e005d2059ff4201b + v_arg2 = 044d7857339c237d | 5cef3a8c204a80e6 + v_arg3 = 59f1984641979aa0 | f46a09e359052b91 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = c7a2d3f5f0597ad2 + r_arg2 = 550020720c738bd1 + r_arg3 = 8b2320b90984c1e2 + r_result = 0000000000000000 +insn vste: + v_arg1 = 2e8e85aa0c09690f | 300a76ca53f97aab + v_arg2 = 9ba674a200b06edb | 11dab0c01f3459d6 + v_arg3 = ba2c5176a27ba473 | 04f134912426d1e7 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 693dbc41d2ca04fc + r_arg2 = fddc527b7985cb45 + r_arg3 = b908a5ac4306bcac + r_result = 0000000000000000 +insn vste: + v_arg1 = 922d8230af4c550a | 7dc0080548c7ec1b + v_arg2 = 58a2ee6511bf33f3 | 7cca0a902c994559 + v_arg3 = 85fbea4362675171 | 18889179e2ab5e7e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 6209ad1ba1483583 + r_arg2 = 0da4441f3f1ebc7a + r_arg3 = c6027a6409d7aa98 + r_result = 0000000000000000 +insn vste: + v_arg1 = 611c5595596f5987 | 8d29b113781789d9 + v_arg2 = 9722950f56406c23 | 4d3d3e37ed6de47c + v_arg3 = 823a5f759b8fa714 | cf2ae2b4e4c600fc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 9f10392d0013089f + r_arg2 = 08410f15f73d4294 + r_arg3 = 8a97fa66a8731278 + r_result = 0000000000000000 +insn vste: + v_arg1 = 114f59abb31bb966 | 6d1651d480507cb1 + v_arg2 = bb958f4c2418ebe6 | fdff77ef2cd46f26 + v_arg3 = fed3a2954e150272 | 0c9f9fd72355f868 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 552ba69b351d91e4 + r_arg2 = 7928404f9d5013d7 + r_arg3 = a79cbc34928815ff + r_result = 0000000000000000 +insn vste: + v_arg1 = 5e849ebf0ba9d2e3 | 2fe43d646747c590 + v_arg2 = ebb737c6f65a1694 | 8bebd6b09be070df + v_arg3 = 8e7f59a922c6d600 | ba3fb5b6fca760e3 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = bec0b4caeec1b805 + r_arg2 = b01e9cc154f18063 + r_arg3 = 42f3470e22ad267b + r_result = 0000000000000000 +insn vste: + v_arg1 = 0a0ba85d17dcd35a | ab4201dc5801fd3d + v_arg2 = d652e0e52d09aa24 | 3aa934f192508c8b + v_arg3 = cc84a3f526e26b51 | 88ac4824f037e66f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = db84551bfe8cfc93 + r_arg2 = 83f7da1a26ab2df8 + r_arg3 = c84ddcb0562ad099 + r_result = 0000000000000000 +insn vste: + v_arg1 = 9e7f340fb3a98303 | 40e81f14646f0e21 + v_arg2 = 70ff918fd1d379eb | 5471df65cc523a2f + v_arg3 = 1877d4ba8bd3a0d6 | ae9a71af6a6e8faa + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 313973af1ef631bd + r_arg2 = 0d516c87c1b5d5b3 + r_arg3 = abe8311993b57424 + r_result = 0000000000000000 +insn vste: + v_arg1 = 288cf41d9ef1ffb5 | 915fcf63412ffdff + v_arg2 = b3e4c8e74fd72c5c | ebc559be2e4089aa + v_arg3 = 59fa34f96bf3a99f | a789006779647692 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 8d70ae24ad284210 + r_arg2 = 735b37763cb408ce + r_arg3 = 23503140653208c5 + r_result = 0000000000000000 +insn vuph: + v_arg1 = fcaa4e4c424479a6 | 48bebe5b0e50a1ba + v_arg2 = fffcffaa004e004c | 004200440079ffa6 + v_arg3 = fffffcaa00004e4c | 00004244000079a6 + v_result = fffffffffcaa4e4c | 00000000424479a6 + r_arg1 = c1461b5571b7f037 + r_arg2 = 9b93574fd17bed62 + r_arg3 = ee20bedf3d71dac2 + r_result = 0000000000000000 +insn vuph: + v_arg1 = 73df22a16a9ffa28 | d669d0900d0d6914 + v_arg2 = 0073ffdf0022ffa1 | 006aff9ffffa0028 + v_arg3 = 000073df000022a1 | 00006a9ffffffa28 + v_result = 0000000073df22a1 | 000000006a9ffa28 + r_arg1 = 6429071c546591bb + r_arg2 = f382dd3ca1cd0126 + r_arg3 = 11c06f2c32f14cc1 + r_result = 0000000000000000 +insn vuph: + v_arg1 = b080811e0a2d216b | 32d3de51688f1b6c + v_arg2 = ffb0ff80ff81001e | 000a002d0021006b + v_arg3 = ffffb080ffff811e | 00000a2d0000216b + v_result = ffffffffb080811e | 000000000a2d216b + r_arg1 = 9793b21229e6d3c3 + r_arg2 = 318191e17318d630 + r_arg3 = 95275399c2a29685 + r_result = 0000000000000000 +insn vuph: + v_arg1 = 56ef7782fb08e240 | 963d796ceeae907e + v_arg2 = 0056ffef0077ff82 | fffb0008ffe20040 + v_arg3 = 000056ef00007782 | fffffb08ffffe240 + v_result = 0000000056ef7782 | fffffffffb08e240 + r_arg1 = bbcd154c659778d3 + r_arg2 = 0e76b123763ad5b2 + r_arg3 = 4b99ac998e9d87ae + r_result = 0000000000000000 +insn vuph: + v_arg1 = 545dc30cbcf748d3 | 4673a6edd4af7926 + v_arg2 = 0054005dffc3000c | ffbcfff70048ffd3 + v_arg3 = 0000545dffffc30c | ffffbcf7000048d3 + v_result = 00000000545dc30c | ffffffffbcf748d3 + r_arg1 = 3cac9d1ee747188f + r_arg2 = 0a96b0e3fb3ffdbd + r_arg3 = 8a69b55d21ed457c + r_result = 0000000000000000 +insn vuph: + v_arg1 = 9a879a373330356f | 4994a0dd74061d1c + v_arg2 = ff9aff87ff9a0037 | 003300300035006f + v_arg3 = ffff9a87ffff9a37 | 000033300000356f + v_result = ffffffff9a879a37 | 000000003330356f + r_arg1 = 4a55eedab0f1e378 + r_arg2 = 2b23f9c23d1fa300 + r_arg3 = ecb75e92aa48098c + r_result = 0000000000000000 +insn vuph: + v_arg1 = e17b687d6a161e3c | 2ec99a06111419b7 + v_arg2 = ffe1007b0068007d | 006a0016001e003c + v_arg3 = ffffe17b0000687d | 00006a1600001e3c + v_result = ffffffffe17b687d | 000000006a161e3c + r_arg1 = 9bfba291ac7e5cac + r_arg2 = be2daadd19833088 + r_arg3 = 15320b23bed5e497 + r_result = 0000000000000000 +insn vuph: + v_arg1 = 68538f1754fbd002 | c90a7bac92e920ac + v_arg2 = 00680053ff8f0017 | 0054fffbffd00002 + v_arg3 = 00006853ffff8f17 | 000054fbffffd002 + v_result = 0000000068538f17 | 0000000054fbd002 + r_arg1 = 2b9e08cf68861fa8 + r_arg2 = 15545a91d67fe780 + r_arg3 = 6cd659fb19e77d38 + r_result = 0000000000000000 +insn vuph: + v_arg1 = b2f727ba86de2ee6 | f5dfa1544402b9cf + v_arg2 = ffb2fff70027ffba | ff86ffde002effe6 + v_arg3 = ffffb2f7000027ba | ffff86de00002ee6 + v_result = ffffffffb2f727ba | ffffffff86de2ee6 + r_arg1 = fdcce661db0e9d08 + r_arg2 = 4983d437df589df1 + r_arg3 = e0acdac35abed2a6 + r_result = 0000000000000000 +insn vuph: + v_arg1 = 4adebd5bfe2cf02b | 501c9f7f990a04cf + v_arg2 = 004affdeffbd005b | fffe002cfff0002b + v_arg3 = 00004adeffffbd5b | fffffe2cfffff02b + v_result = 000000004adebd5b | fffffffffe2cf02b + r_arg1 = d86337111e4adb45 + r_arg2 = f6b5d9e8853e7f81 + r_arg3 = a58fd49fca4bf374 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 7fcc15eae08166f1 | 02a3ff6eeb9a76fd + v_arg2 = 007f00cc001500ea | 00e00081006600f1 + v_arg3 = 00007fcc000015ea | 0000e081000066f1 + v_result = 000000007fcc15ea | 00000000e08166f1 + r_arg1 = 0b4cee67345b3774 + r_arg2 = 02b2e339bf11d036 + r_arg3 = f5e406f316ebcb57 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 2994e818356734f8 | 772401df3afc9905 + v_arg2 = 0029009400e80018 | 00350067003400f8 + v_arg3 = 000029940000e818 | 00003567000034f8 + v_result = 000000002994e818 | 00000000356734f8 + r_arg1 = 293fb369c311240c + r_arg2 = 56d1ddfee91fa933 + r_arg3 = d0606423102ad7df + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 62d6a714ab14145c | 21df5bcdeae2ceb1 + v_arg2 = 006200d600a70014 | 00ab00140014005c + v_arg3 = 000062d60000a714 | 0000ab140000145c + v_result = 0000000062d6a714 | 00000000ab14145c + r_arg1 = ce84a15adaa8ea9f + r_arg2 = a4b6ed0989e3b779 + r_arg3 = bdc5d74c7380ed3b + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 4ec13748592f9859 | 375ff73387320bac + v_arg2 = 004e00c100370048 | 0059002f00980059 + v_arg3 = 00004ec100003748 | 0000592f00009859 + v_result = 000000004ec13748 | 00000000592f9859 + r_arg1 = 5aaf0f7daa8d679e + r_arg2 = 20142bea06c601a6 + r_arg3 = 88a3fe0f9d15f7f8 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = d5d0b320788ae607 | 793eb9c782bd9d3b + v_arg2 = 00d500d000b30020 | 0078008a00e60007 + v_arg3 = 0000d5d00000b320 | 0000788a0000e607 + v_result = 00000000d5d0b320 | 00000000788ae607 + r_arg1 = b16244d24d19d118 + r_arg2 = 486b67af6fe0a1b7 + r_arg3 = 0219f0455480b6c1 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 648f2ec22be77a1d | ebe737c1f102e804 + v_arg2 = 0064008f002e00c2 | 002b00e7007a001d + v_arg3 = 0000648f00002ec2 | 00002be700007a1d + v_result = 00000000648f2ec2 | 000000002be77a1d + r_arg1 = 020d41d68253727b + r_arg2 = 9cc9e7a43bb687c8 + r_arg3 = c594f9cb8282801e + r_result = 0000000000000000 +insn vuplh: + v_arg1 = b1556fd439b6e8b1 | 964d7f9453ee23c9 + v_arg2 = 00b10055006f00d4 | 003900b600e800b1 + v_arg3 = 0000b15500006fd4 | 000039b60000e8b1 + v_result = 00000000b1556fd4 | 0000000039b6e8b1 + r_arg1 = 7db07c456fb16b50 + r_arg2 = 678b281304fc3ad1 + r_arg3 = ed8e5936f9ce0238 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 740ab43cced498f4 | 4bb7d5b34b9d1d2c + v_arg2 = 0074000a00b4003c | 00ce00d4009800f4 + v_arg3 = 0000740a0000b43c | 0000ced4000098f4 + v_result = 00000000740ab43c | 00000000ced498f4 + r_arg1 = 1b95a0da5ed67300 + r_arg2 = 751c99044b52966a + r_arg3 = e14f089e30c40092 + r_result = 0000000000000000 +insn vuplh: + v_arg1 = 2fe270da3e4d89f9 | 5f77734c6119fb6c + v_arg2 = 002f00e2007000da | 003e004d008900f9 + v_arg3 = 00002fe2000070da | 00003e4d000089f9 + v_result = 000000002fe270da | 000000003e4d89f9 + r_arg1 = 5b194e0c82539594 + r_arg2 = dbb463fd380a8f87 + r_arg3 = 09ae7556042f11cf + r_result = 0000000000000000 +insn vuplh: + v_arg1 = e71e0d4fc2190f6e | 71ad480ec418f825 + v_arg2 = 00e7001e000d004f | 00c20019000f006e + v_arg3 = 0000e71e00000d4f | 0000c21900000f6e + v_result = 00000000e71e0d4f | 00000000c2190f6e + r_arg1 = 0063e0d2b069f66f + r_arg2 = b41925c157dfed3a + r_arg3 = 95cf43af790d6472 + r_result = 0000000000000000 +insn vupl: + v_arg1 = e9d1abb839e09560 | 2007bbe60bc02413 + v_arg2 = 00200007ffbbffe6 | 000bffc000240013 + v_arg3 = 00002007ffffbbe6 | 00000bc000002413 + v_result = 000000002007bbe6 | 000000000bc02413 + r_arg1 = d52a215e27c48d15 + r_arg2 = de5fb0135dbe0f76 + r_arg3 = 3de50cbc77467e98 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 8797df72e9b85df9 | d68365bcf06526cd + v_arg2 = ffd6ff830065ffbc | fff000650026ffcd + v_arg3 = ffffd683000065bc | fffff065000026cd + v_result = ffffffffd68365bc | fffffffff06526cd + r_arg1 = 697217e44940e9e7 + r_arg2 = c1aad072e180a9c9 + r_arg3 = fcef1e088e71fabe + r_result = 0000000000000000 +insn vupl: + v_arg1 = d95e76d63de53b44 | 8129db391449fb8d + v_arg2 = ff810029ffdb0039 | 00140049fffbff8d + v_arg3 = ffff8129ffffdb39 | 00001449fffffb8d + v_result = ffffffff8129db39 | 000000001449fb8d + r_arg1 = d44eba5360a6efe3 + r_arg2 = 09e904dd24ac8720 + r_arg3 = d47e4160b4954980 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 7d1f30fc85975ee6 | 54d46282bf59b5e5 + v_arg2 = 0054ffd40062ff82 | ffbf0059ffb5ffe5 + v_arg3 = 000054d400006282 | ffffbf59ffffb5e5 + v_result = 0000000054d46282 | ffffffffbf59b5e5 + r_arg1 = 719dba185a6f9a66 + r_arg2 = 689b418fca374886 + r_arg3 = 8e6c708d02e57056 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 58a4867abaae08e5 | 8be8b9fd9ef53d8a + v_arg2 = ff8bffe8ffb9fffd | ff9efff5003dff8a + v_arg3 = ffff8be8ffffb9fd | ffff9ef500003d8a + v_result = ffffffff8be8b9fd | ffffffff9ef53d8a + r_arg1 = a2d03de18d7ebbec + r_arg2 = 568db3c39f4624e4 + r_arg3 = 78a59b197a82cd57 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 5343662537775164 | 251cd30a83a7130b + v_arg2 = 0025001cffd3000a | ff83ffa70013000b + v_arg3 = 0000251cffffd30a | ffff83a70000130b + v_result = 00000000251cd30a | ffffffff83a7130b + r_arg1 = 90a19f5775e8b7ce + r_arg2 = d1987c7054eaa7c0 + r_arg3 = 25e06c09c43bd2f9 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 1fa0f2ce816fe963 | a9309bc929ea0999 + v_arg2 = ffa90030ff9bffc9 | 0029ffea0009ff99 + v_arg3 = ffffa930ffff9bc9 | 000029ea00000999 + v_result = ffffffffa9309bc9 | 0000000029ea0999 + r_arg1 = e8db32e172ae4c01 + r_arg2 = 1d66740c40e17401 + r_arg3 = 316500a0ed4ec9ce + r_result = 0000000000000000 +insn vupl: + v_arg1 = f26e450501fed482 | e2b7afd9ede30cbf + v_arg2 = ffe2ffb7ffafffd9 | ffedffe3000cffbf + v_arg3 = ffffe2b7ffffafd9 | ffffede300000cbf + v_result = ffffffffe2b7afd9 | ffffffffede30cbf + r_arg1 = 9f18fc668b804ddc + r_arg2 = 852de74c205a03a7 + r_arg3 = fbc7aa2028278f46 + r_result = 0000000000000000 +insn vupl: + v_arg1 = 482c2ed8c63b2cbd | a4cd26169729db2a + v_arg2 = ffa4ffcd00260016 | ff970029ffdb002a + v_arg3 = ffffa4cd00002616 | ffff9729ffffdb2a + v_result = ffffffffa4cd2616 | ffffffff9729db2a + r_arg1 = b07c7c0a2f7b61d1 + r_arg2 = 19715be0d7b06496 + r_arg3 = 69aab48b8e1e5972 + r_result = 0000000000000000 +insn vupl: + v_arg1 = a4eaf39344ade22f | 85df4b59107fce61 + v_arg2 = ff85ffdf004b0059 | 0010007fffce0061 + v_arg3 = ffff85df00004b59 | 0000107fffffce61 + v_result = ffffffff85df4b59 | 00000000107fce61 + r_arg1 = da7e66eeefeac831 + r_arg2 = 6fc5493a2f2cfb4b + r_arg3 = a87d1e5cde3c73be + r_result = 0000000000000000 +insn vupll: + v_arg1 = 4d04108018067ed2 | a469603a2997928c + v_arg2 = 00a400690060003a | 002900970092008c + v_arg3 = 0000a4690000603a | 000029970000928c + v_result = 00000000a469603a | 000000002997928c + r_arg1 = 639e63f4450717eb + r_arg2 = 6388df4797c642a3 + r_arg3 = eb3f5d523ef6fdb5 + r_result = 0000000000000000 +insn vupll: + v_arg1 = 12e5f6a6c2e9db3d | 66b25ccf5bd0e830 + v_arg2 = 006600b2005c00cf | 005b00d000e80030 + v_arg3 = 000066b200005ccf | 00005bd00000e830 + v_result = 0000000066b25ccf | 000000005bd0e830 + r_arg1 = d82ed27750b9f84c + r_arg2 = d8aac532e4e48b9a + r_arg3 = 283c1e24f8efadbf + r_result = 0000000000000000 +insn vupll: + v_arg1 = 07c4cd8c69a4ed63 | 3590ae6d82f76af0 + v_arg2 = 0035009000ae006d | 008200f7006a00f0 + v_arg3 = 000035900000ae6d | 000082f700006af0 + v_result = 000000003590ae6d | 0000000082f76af0 + r_arg1 = cb0c8a159656ecbf + r_arg2 = 7567d5271118bb08 + r_arg3 = ded0014c3eb890e5 + r_result = 0000000000000000 +insn vupll: + v_arg1 = 466933f69bf57c59 | 4129f865a209464c + v_arg2 = 0041002900f80065 | 00a200090046004c + v_arg3 = 000041290000f865 | 0000a2090000464c + v_result = 000000004129f865 | 00000000a209464c + r_arg1 = 94659667c261098d + r_arg2 = 680ae20cffe41165 + r_arg3 = d2225fbfe791ca8a + r_result = 0000000000000000 +insn vupll: + v_arg1 = afe7fba60bc8e70e | 3faed6c6a3ed0163 + v_arg2 = 003f00ae00d600c6 | 00a300ed00010063 + v_arg3 = 00003fae0000d6c6 | 0000a3ed00000163 + v_result = 000000003faed6c6 | 00000000a3ed0163 + r_arg1 = 1172f8c6644cbd9d + r_arg2 = 27aa73483677de84 + r_arg3 = cde806b231285232 + r_result = 0000000000000000 +insn vupll: + v_arg1 = a961f01b53f5e213 | 2d219520153d35b4 + v_arg2 = 002d002100950020 | 0015003d003500b4 + v_arg3 = 00002d2100009520 | 0000153d000035b4 + v_result = 000000002d219520 | 00000000153d35b4 + r_arg1 = 673d6807b5368933 + r_arg2 = 2bef867fa2704b5a + r_arg3 = 6128f8557d58b73d + r_result = 0000000000000000 +insn vupll: + v_arg1 = e0c89054b0053854 | 0c0ffd3eecfd54d7 + v_arg2 = 000c000f00fd003e | 00ec00fd005400d7 + v_arg3 = 00000c0f0000fd3e | 0000ecfd000054d7 + v_result = 000000000c0ffd3e | 00000000ecfd54d7 + r_arg1 = bf5c133e51acc7b3 + r_arg2 = b4cc4e52589916b7 + r_arg3 = a2f3309a17eadeab + r_result = 0000000000000000 +insn vupll: + v_arg1 = 059ad28cc9ec8adb | a45508ea45606447 + v_arg2 = 00a40055000800ea | 0045006000640047 + v_arg3 = 0000a455000008ea | 0000456000006447 + v_result = 00000000a45508ea | 0000000045606447 + r_arg1 = 0ab25d7dfb6b655d + r_arg2 = 8944f52250ac550a + r_arg3 = ed2b5dedec56c1d8 + r_result = 0000000000000000 +insn vupll: + v_arg1 = 92a4e1fd69cf0e93 | 45dda8ab2188c21a + v_arg2 = 004500dd00a800ab | 0021008800c2001a + v_arg3 = 000045dd0000a8ab | 000021880000c21a + v_result = 0000000045dda8ab | 000000002188c21a + r_arg1 = be349f945d1aa811 + r_arg2 = b5285bcc28103320 + r_arg3 = a53da5fc52813340 + r_result = 0000000000000000 +insn vupll: + v_arg1 = 84bfdfa040be5201 | 816086882645e0c5 + v_arg2 = 0081006000860088 | 0026004500e000c5 + v_arg3 = 0000816000008688 | 000026450000e0c5 + v_result = 0000000081608688 | 000000002645e0c5 + r_arg1 = 98a0ead1c513eb0c + r_arg2 = 4cd6d56de89bafe4 + r_arg3 = f2e6646fc57f983b + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 1f95a3eaa779f80b | f325bec561d407dc + v_arg2 = fa6a5773dadb7a2d | f57cbf263e3385d7 + v_arg3 = 2c813ccda073b24f | 2c6dcdd6b8dda16c + v_result = 9595959595959595 | 9595959595959595 + r_arg1 = 5846c2c1ea195ea8 + r_arg2 = 24fbef1eb950601f + r_arg3 = 81f0ebafa451adc0 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = ae5b7c8f5a2e78b4 | fcbfa5a407a116ce + v_arg2 = 24a7bf005c15063d | 9daac0849d908167 + v_arg3 = 252b568db2c5d710 | 801da3b7ead4301a + v_result = 5b5b5b5b5b5b5b5b | 5b5b5b5b5b5b5b5b + r_arg1 = 89c2e5eca522c81e + r_arg2 = 9d502cb8ad213437 + r_arg3 = 47f442a2f8a64725 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 4097ec423c38e1dc | 81d184242f0442ac + v_arg2 = a9ce54e17c7617a2 | a560bbc639b26173 + v_arg3 = 69ea8c60e748f7f1 | af1ccf372af644cc + v_result = 9797979797979797 | 9797979797979797 + r_arg1 = 37be039bb90d4646 + r_arg2 = 5a5ec2907aac2df2 + r_arg3 = 3e19e76b2e9d0cdb + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 6dda6f7117e09903 | afcc5bc39a06d4e2 + v_arg2 = 0bec5e61ad849e77 | a50afdc7fd5c7d84 + v_arg3 = 6648f06e60bd8dab | bed4e68d90c34029 + v_result = dadadadadadadada | dadadadadadadada + r_arg1 = b7b483938d6b0b54 + r_arg2 = 053d5f3a40002333 + r_arg3 = 27d28d2ed9803c35 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 1086320b591e1905 | b8ae9f3e6d1beffa + v_arg2 = 935d58cc8bf123b3 | bb24c71eba4081c1 + v_arg3 = d09e4a5ce3932c52 | b73af82b97265cf2 + v_result = 8686868686868686 | 8686868686868686 + r_arg1 = 63a845d9ed391e9a + r_arg2 = 104fe7483f5986ba + r_arg3 = 47a2dfc872896b21 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 0b87dc3dd957b2dd | 94c3fc4ef2e7485e + v_arg2 = 0f8eb328986081ef | 4cf410e1e6bc30af + v_arg3 = 61d3d80f9da83e19 | 69934885e43d68c8 + v_result = 8787878787878787 | 8787878787878787 + r_arg1 = 5bf05b6fcda21f4b + r_arg2 = 6f09340aa2de19e7 + r_arg3 = 2bda3b9a189f45ec + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 071c4a2f901e4c65 | c167146c5afdec16 + v_arg2 = 93b597fcfa1fab20 | c2524664609f22f0 + v_arg3 = 991a0e68e308c011 | 2b330fcaff1087ec + v_result = 1c1c1c1c1c1c1c1c | 1c1c1c1c1c1c1c1c + r_arg1 = 46eecf1507c00336 + r_arg2 = 60a9d54e3868b977 + r_arg3 = 6458783d51174a01 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = 318e4bca61f62214 | 04c03f8d7e9afe84 + v_arg2 = 3899a10c3feb6b57 | 4c630efa2ae58706 + v_arg3 = 7fb65509edac08e9 | 9a383ea81957f6f8 + v_result = 8e8e8e8e8e8e8e8e | 8e8e8e8e8e8e8e8e + r_arg1 = 10d36108185bd386 + r_arg2 = 24ffd020363d1444 + r_arg3 = 4c48a14dc87690a8 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = fff66974d30e88bd | 26864ae59b6c762e + v_arg2 = e14fa7191ab21e86 | a158ffb12e75e30f + v_arg3 = 5eb8cc0d993b7faf | 5752390ac536c3a9 + v_result = f6f6f6f6f6f6f6f6 | f6f6f6f6f6f6f6f6 + r_arg1 = aa5d46c4e7a77286 + r_arg2 = c427618af7cf7307 + r_arg3 = c0e5b7220d2d84c9 + r_result = 0000000000000000 +insn vrepb: + v_arg1 = eafba0d0d202a555 | b8be39a61250e473 + v_arg2 = f1f970a4244b7a3d | bd326c19fbe8d089 + v_arg3 = 8abe0ad22fcb688c | ca7d9edcbf039798 + v_result = fbfbfbfbfbfbfbfb | fbfbfbfbfbfbfbfb + r_arg1 = ce98ebc47f095561 + r_arg2 = cd4bb953bc807117 + r_arg3 = e5387490585aa9a9 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 32902581739f3aab | d07905c12e0e2c53 + v_arg2 = 17887daa9c3e4967 | a38018fc8544c00e + v_arg3 = 19b4dab2189f988a | e3c3fcc4a9fe6dfa + v_result = 2581258125812581 | 2581258125812581 + r_arg1 = b99fb03fd1d149dd + r_arg2 = 1564c0c36d60c22a + r_arg3 = e4d603ad478d58ab + r_result = 0000000000000000 +insn vreph: + v_arg1 = 9db821e7ad9d5a30 | ca985fa2de1d492a + v_arg2 = 037ac36828822c11 | 1a1e0026e9bbb918 + v_arg3 = ab95fec4a6e83d50 | d4fd9deac9165966 + v_result = 21e721e721e721e7 | 21e721e721e721e7 + r_arg1 = ef5baeeb73ff321e + r_arg2 = 74f8d45c57eced12 + r_arg3 = aea4ca8a9b7f7f0f + r_result = 0000000000000000 +insn vreph: + v_arg1 = 384473df206530b0 | 098a6cf677640a73 + v_arg2 = 2e9b6f1792385922 | 72f6151d276f17bd + v_arg3 = 2329ee9ed08798e2 | d8913eb0cda9438e + v_result = 73df73df73df73df | 73df73df73df73df + r_arg1 = fb4172bd6400c668 + r_arg2 = 8cdc88a1edcf137f + r_arg3 = b89621f700da63b5 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 15917286d3ccbc15 | b40b886774f6d888 + v_arg2 = 97c6a2b08d735d22 | 3dc100e8e7304e72 + v_arg3 = 6cc89614f3c8c364 | f034d1788843aa03 + v_result = 7286728672867286 | 7286728672867286 + r_arg1 = 2d16c0a6c67157db + r_arg2 = 82f267d187a3a7c2 + r_arg3 = c06a1842c3f65eda + r_result = 0000000000000000 +insn vreph: + v_arg1 = 0c4eaaf5eed5972a | 7ae5045d37d46f5f + v_arg2 = 80a333a86ef2dcf6 | 16c5ddca353aa6ca + v_arg3 = 35141cf893266cd7 | a1a84263b35d62f4 + v_result = aaf5aaf5aaf5aaf5 | aaf5aaf5aaf5aaf5 + r_arg1 = 5aae5255a3da8737 + r_arg2 = c3ebafab26b03487 + r_arg3 = 886f36f79a98a2d7 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 7c339b048571ab54 | 4fb1e7bec6ada14d + v_arg2 = 366a70b3f3e24da0 | 5d97000745fbfe37 + v_arg3 = b6c198db180d98d9 | b87d300fae1e56ee + v_result = 9b049b049b049b04 | 9b049b049b049b04 + r_arg1 = a0a797faaa721199 + r_arg2 = c104172a2faa1b99 + r_arg3 = 974335a061b4f5e7 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 07c97e094e41fd59 | 2d95b1ad8e9f17c6 + v_arg2 = c79ddd8300a0bf02 | f9d9b49c31ca8ac6 + v_arg3 = 6a4fdbc992926268 | 07d3b1573c1b479d + v_result = 7e097e097e097e09 | 7e097e097e097e09 + r_arg1 = 21307500efe0873b + r_arg2 = b4cc8a492c7552a1 + r_arg3 = fc8fc784d82c74e1 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 5a27ff996551641b | d406144d24f60f19 + v_arg2 = cbd0f4885e73979a | 16fcf70ab6af95e5 + v_arg3 = d3cd2a10763bba9e | 25150f154b198c87 + v_result = ff99ff99ff99ff99 | ff99ff99ff99ff99 + r_arg1 = c3c708d0aff70f36 + r_arg2 = 5adbe9bf8fe327e5 + r_arg3 = 0acc556b668d51f8 + r_result = 0000000000000000 +insn vreph: + v_arg1 = e3b1044510dc4f5c | 8b86ba7d00ea2037 + v_arg2 = 1d63e5b07b555046 | e5fd400afb20401f + v_arg3 = 3a9600f85fbc2774 | 32be8ee2aac8d0d6 + v_result = 0445044504450445 | 0445044504450445 + r_arg1 = f7f561930a772642 + r_arg2 = b89acec26f73fc0b + r_arg3 = 1d00bb57d9d79581 + r_result = 0000000000000000 +insn vreph: + v_arg1 = 99da665d760e847b | dd65039c4164f26b + v_arg2 = 9e4554272eaa3a01 | 602a3a594bc042de + v_arg3 = 6c16d08aceb68682 | 921723d3d189d80d + v_result = 665d665d665d665d | 665d665d665d665d + r_arg1 = 701348f0c8d15e72 + r_arg2 = d70044c7491209d6 + r_arg3 = 55800e4b2434dfac + r_result = 0000000000000000 +insn vrepf: + v_arg1 = b9e3b4ae66bcdc34 | 5e83c5466cb80722 + v_arg2 = f9b11e1770053ca2 | 04dd876cd721a726 + v_arg3 = 7e85c04ceb79c9bc | aef53f3c9e283bd0 + v_result = 66bcdc3466bcdc34 | 66bcdc3466bcdc34 + r_arg1 = e707fbc815e320fb + r_arg2 = 8851913ec1dd1de6 + r_arg3 = 56ae570620be2347 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = 8498f446172c0863 | 640b0b142d6b76a3 + v_arg2 = 5af3146824e993a2 | 953f7f3b7582925f + v_arg3 = 8ba9700143c2b935 | b77d836f13a029a0 + v_result = 172c0863172c0863 | 172c0863172c0863 + r_arg1 = de06ed0045b66bed + r_arg2 = 21e0ed595fdb5e7b + r_arg3 = 0fbb55c64c3c6d81 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = 0218612ee3d24fc0 | cf38d65e15edabd6 + v_arg2 = 3723be7fd08492d6 | de05eef86490fb0a + v_arg3 = 7297b26c897cb6df | 63e2897c19dd259b + v_result = e3d24fc0e3d24fc0 | e3d24fc0e3d24fc0 + r_arg1 = 5b528836924694f7 + r_arg2 = 3fcd48c453c60532 + r_arg3 = 70643f098ee49ca4 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = c28c2e2d0b0f4ea2 | c212dffa5b5f2900 + v_arg2 = 08e71a026274602f | 6f34dad707287289 + v_arg3 = 9971500d55807247 | ae24a2f24174cb3f + v_result = 0b0f4ea20b0f4ea2 | 0b0f4ea20b0f4ea2 + r_arg1 = a9fbed88da380426 + r_arg2 = 82c7096d32c223c5 + r_arg3 = 32b78146f11a28d8 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = 98ec428b76f3b8be | 683054fd9c4d4883 + v_arg2 = 0f345c90ed85bd7f | 5edf3bc7a611dada + v_arg3 = ad27c9e1e858ba5b | 9bd1939b7e6b8c26 + v_result = 76f3b8be76f3b8be | 76f3b8be76f3b8be + r_arg1 = 1ba1af5362a4fea5 + r_arg2 = 55caca3cb72260cd + r_arg3 = 94ce7bb7652ddde6 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = 5fc0faca73fa14e8 | b17697779c72f8a1 + v_arg2 = 110cac8c6a6fbe36 | 07e6c23630c5305b + v_arg3 = 60391525e7f72d26 | f1c75842edf66dc9 + v_result = 73fa14e873fa14e8 | 73fa14e873fa14e8 + r_arg1 = c92f9cf096cb577d + r_arg2 = a4df1dda8329b781 + r_arg3 = 19914611821f9ef1 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = b5dceb6c73d182d0 | 12d7033a03797d39 + v_arg2 = 1b3fecd2799b8d1f | ccb794d0fc274286 + v_arg3 = 2a725d121c810391 | feefe26f8d36cd40 + v_result = 73d182d073d182d0 | 73d182d073d182d0 + r_arg1 = 52a07578c6e13c54 + r_arg2 = a4e14b6ddec53b77 + r_arg3 = 4b776e48465c233c + r_result = 0000000000000000 +insn vrepf: + v_arg1 = c2229fb2d11177c4 | 4913a79321b93187 + v_arg2 = 3f2d707e1ddd2a26 | d6100c3f844d79b5 + v_arg3 = 09adc5a03907c923 | 5801d92808fa1cfe + v_result = d11177c4d11177c4 | d11177c4d11177c4 + r_arg1 = 99bcb180ebc3f031 + r_arg2 = 8f3510597554d660 + r_arg3 = 7c44b94fd381bce9 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = f242545a8a017d73 | 1779090dabf846e7 + v_arg2 = 5481c4ab843a2d15 | d3ba7ceb293690de + v_arg3 = 42922245954a20c0 | 98455bb06981a598 + v_result = 8a017d738a017d73 | 8a017d738a017d73 + r_arg1 = 88da3fdc61c08c35 + r_arg2 = 659061ff1b6105cf + r_arg3 = 80cbe0d432150db7 + r_result = 0000000000000000 +insn vrepf: + v_arg1 = b77cc05f0657f5a6 | 05a4e5347c278190 + v_arg2 = bbf56a30bda28351 | b64dedb9f3935b56 + v_arg3 = 1f58c5b6ed76816c | 1e4fbb4ae435457f + v_result = 0657f5a60657f5a6 | 0657f5a60657f5a6 + r_arg1 = d19e415eab52be61 + r_arg2 = adb4268089669ef2 + r_arg3 = 75ac52071452d0c3 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 485bd0bbcdf6d508 | 2140ec4e562a015b + v_arg2 = 1513996381b52d9f | 7bf1dcce4e818190 + v_arg3 = af832fa425e8fc08 | d1c144f5926f32c0 + v_result = 2140ec4e562a015b | 2140ec4e562a015b + r_arg1 = a8bbd29633e48a55 + r_arg2 = 333101791e8b8b56 + r_arg3 = 7c16f4528cdb9746 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 6579642753b06ade | bec587229f90f77d + v_arg2 = 0ef100d8eb8105e4 | e11afb4cce4c43dd + v_arg3 = 89a6da7f05e7f512 | dd0bf4303238b6c9 + v_result = bec587229f90f77d | bec587229f90f77d + r_arg1 = 8ab1c292088d0d0d + r_arg2 = c82606c79f648da6 + r_arg3 = 7e84e420d785885b + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 124115d8ae0318ce | 383892b425556c47 + v_arg2 = 16f38222404079df | 2f4af612ed2c342d + v_arg3 = 8921f735fd6ce768 | 732d41b7ea05f225 + v_result = 383892b425556c47 | 383892b425556c47 + r_arg1 = fa8e559e9ed236a5 + r_arg2 = 06008143f8b6fa6a + r_arg3 = e882329915121fb8 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 58a6f1425bde169a | aef02106dba6feec + v_arg2 = 238cf890a91d4eef | f0d12c7fc909ffcb + v_arg3 = 92e22bf2e2dd2204 | 8c71d84305799d3d + v_result = aef02106dba6feec | aef02106dba6feec + r_arg1 = 40af080492678c16 + r_arg2 = 0939b486fa3180cb + r_arg3 = 6f67a6630df0f073 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 07ef3ad7fd5d33e5 | c64e3fd7999ca339 + v_arg2 = 72fcf2eff4ef5fd2 | b78e722ee73a2523 + v_arg3 = 4b2652dfb0cc8dbf | a7345a4cb326c217 + v_result = c64e3fd7999ca339 | c64e3fd7999ca339 + r_arg1 = 297f4dcc65edebf5 + r_arg2 = 381997a41c35e04c + r_arg3 = ce1b7d62edfd63be + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 776e2bc81e8794eb | 6d82aa65e0fe665d + v_arg2 = 4311774d58fb5c62 | ddaed5baf340bd7e + v_arg3 = e3383de646bb6511 | 879d1ec8cd4a8619 + v_result = 6d82aa65e0fe665d | 6d82aa65e0fe665d + r_arg1 = ca364a7b3cb34739 + r_arg2 = fa7797f33c90b491 + r_arg3 = 84d22c77084477a9 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 4343b3c1ed15744b | 954b992d950126a1 + v_arg2 = a0e9c1b22eb58c59 | 3e6b557a7d8e32c3 + v_arg3 = ce2f746b2ddafcce | f763f3ec8e94e0c6 + v_result = 954b992d950126a1 | 954b992d950126a1 + r_arg1 = 3d999ed7a77868f4 + r_arg2 = 827758c45b3c2a1a + r_arg3 = 97cd1c4397bf80e5 + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 0e1c38afff2de3c0 | f6b677a8c20a5a2f + v_arg2 = 17ac03e7b97e8c0d | 00cdab44be430937 + v_arg3 = 86b3f51352c67be9 | 868adbe95be05f7f + v_result = f6b677a8c20a5a2f | f6b677a8c20a5a2f + r_arg1 = 63bf1d9f5725ad17 + r_arg2 = 854c73276524c807 + r_arg3 = 541f6de37a16e97e + r_result = 0000000000000000 +insn vrepg: + v_arg1 = 3ff6567c0e2188e2 | cfdda60f596ad0ce + v_arg2 = 7c552332e0650e33 | 4d6a042c52ed993c + v_arg3 = 4cb8f380c84aa133 | 4c25d1ae7df5e942 + v_result = cfdda60f596ad0ce | cfdda60f596ad0ce + r_arg1 = a1c99056e796ca31 + r_arg2 = fff539aae7df26d4 + r_arg3 = 0d64b5b3f55df49e + r_result = 0000000000000000 +insn vrepg: + v_arg1 = c5dc9ed0be3360e8 | a2a83d17f11f6aa3 + v_arg2 = a9698117efe89b9e | 1428c445fd46d214 + v_arg3 = e53f98118821821c | a41385abe24c776d + v_result = a2a83d17f11f6aa3 | a2a83d17f11f6aa3 + r_arg1 = a4a776f894518b2f + r_arg2 = f2036f19d772b81d + r_arg3 = da8abe0e73d87550 + r_result = 0000000000000000 +insn vrepib: + v_arg1 = d3a658d153537d67 | fc8ecbb48899e0f1 + v_arg2 = 3ebcaf175ab35200 | ccf9455d67f9f79d + v_arg3 = 5e1bc4a431b04a6f | f0c51b8be1cbda7a + v_result = 1212121212121212 | 1212121212121212 + r_arg1 = 1ed8c6c1064c8f1b + r_arg2 = 2750103e5010825a + r_arg3 = 598a4c0c47b99b39 + r_result = 0000000000000000 +insn vrepih: + v_arg1 = a5b942e27ddec913 | 2b5213d83f7082d8 + v_arg2 = 623237737a5fa7a6 | 329d96c3df5d6415 + v_arg3 = c8a8cd56c8cef818 | 58f5f0f7f38479c2 + v_result = f012f012f012f012 | f012f012f012f012 + r_arg1 = 8629abec06aa0ee0 + r_arg2 = ebc70fa154dce2a2 + r_arg3 = 6e2ed54166dfa85f + r_result = 0000000000000000 +insn vrepif: + v_arg1 = 3acc50660d5fc17b | 06c9ce332231f317 + v_arg2 = 817a58e84e32263e | 07623d041c374ad6 + v_arg3 = fd933e41797e24e0 | 8c6e55597b79113d + v_result = fffff012fffff012 | fffff012fffff012 + r_arg1 = dc734770457c9404 + r_arg2 = d422134789a44a6b + r_arg3 = 05cc47832f98b4e5 + r_result = 0000000000000000 +insn vrepig: + v_arg1 = 199f6a7dbe503ad0 | aa926cf3de11efcc + v_arg2 = 0cd3ca733ce42f94 | d3e5f5a8f87a6e19 + v_arg3 = 5a98993c56b2ba2d | 7eca5395805a753e + v_result = fffffffffffff012 | fffffffffffff012 + r_arg1 = 646072c31c83c46b + r_arg2 = 7ba63975fda70447 + r_arg3 = cc08c6a3245e6fcb + r_result = 0000000000000000 +insn vpksh: + v_arg1 = 0dc432c4eed8209e | 38dbd48489b60731 + v_arg2 = 3cca760dcf57b74f | a6d171f83409eeb6 + v_arg3 = 833e159d1409bdc6 | 2a2d66d06e434c3a + v_result = 7f7f807f7f80807f | 7f7f8080807f7f80 + r_arg1 = 6726799a47eb1619 + r_arg2 = 40e7d66de24eeda7 + r_arg3 = fa956c31ae9cddb1 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = e95abb18628d328f | 982120505ef46060 + v_arg2 = d0f83f6f775c0eb7 | d29d18ba3872fde1 + v_arg3 = 239c60f8d191068c | 4f0e432bd981d781 + v_result = 80807f7f807f7f7f | 807f7f7f807f7f80 + r_arg1 = f649e0a5aa0f9aee + r_arg2 = 0989342e53f53a99 + r_arg3 = 0bf2083bde691893 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = 46cb53510633c92d | 39ef637f7f8c790f + v_arg2 = cbc7bdce4d749470 | b251c8f2d1b3a2ed + v_arg3 = aa155fdfd1840241 | 33ed92873a4da802 + v_result = 7f7f7f807f7f7f7f | 80807f8080808080 + r_arg1 = a75b20560d3bb46a + r_arg2 = 03fb50370ea2378c + r_arg3 = 822fe00d2749128d + r_result = 0000000000000000 +insn vpksh: + v_arg1 = 40943b0aab7a8fa0 | cf9c63b7b2eee253 + v_arg2 = 382dfd9dcd8b823f | 674094a1f1f87e0c + v_arg3 = 0d1eeaa23c0d7843 | 631cb542b18f6c0a + v_result = 7f7f8080807f8080 | 7f8080807f80807f + r_arg1 = 56be6a99df64de69 + r_arg2 = 603ca34339ca040a + r_arg3 = a6a870f026f25097 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = 3dfc6b56c8c1486a | 140f60db25f70660 + v_arg2 = e76d43509abca8c3 | 96cd87887359840b + v_arg3 = 8af69110e202424f | 717980f7c29ba304 + v_result = 7f7f807f7f7f7f7f | 807f808080807f80 + r_arg1 = e55f639cf7f06ae7 + r_arg2 = 1998d60d1e12577c + r_arg3 = 46c829ee5b04b048 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = a7d94f8b3ad88d31 | 897ecbce2bb2e245 + v_arg2 = 2ddcc9173d132a3b | 2c2a5fe4d49fbf18 + v_arg3 = 636b5a33f9aa0f41 | b531ff4018f56339 + v_result = 807f7f8080807f80 | 7f807f7f7f7f8080 + r_arg1 = fd7be6884f733dbc + r_arg2 = aa6b8d0cef0a3de8 + r_arg3 = 76c6348bedce2595 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = ad518df904b88c74 | 3329102ffd19ccb3 + v_arg2 = a8987e9ee7454345 | 1b135231fcff0f7e + v_arg3 = 9e9a8116da7828d2 | 0d7d3476460f1a90 + v_result = 80807f807f7f8080 | 807f807f7f7f807f + r_arg1 = cc5dc644c86e9660 + r_arg2 = d9dc1e3684f3dab4 + r_arg3 = 506a2d8c6b0e7792 + r_result = 0000000000000000 +insn vpksh: + v_arg1 = 0795bdb2104cca53 | 5f224e1d7ad32eb5 + v_arg2 = f951c7d22b78039b | 1b95cdeaf4dbed66 + v_arg3 = ccad3881c7cc2958 | 9e67d76d8108494d + v_result = 7f807f807f7f7f7f | 80807f7f7f808080 + r_arg1 = c61c8a37ea11c6a7 + r_arg2 = 6fa157bf18792563 + r_arg3 = b4c7e8b386af052f + r_result = 0000000000000000 +insn vpksh: + v_arg1 = afa73043ed2ae14a | 5e071af4e7f64978 + v_arg2 = 8903429dc60011d7 | 6acc3147ae872397 + v_arg3 = c09d65baa9b7c487 | 9185143c686d4ad4 + v_result = 807f80807f7f807f | 807f807f7f7f807f + r_arg1 = 65602f04a2f8f683 + r_arg2 = fec03cda1077ad55 + r_arg3 = 09002f7fd88c83fa + r_result = 0000000000000000 +insn vpksh: + v_arg1 = a914aa78905943f4 | 4ac5410db1c5f403 + v_arg2 = 46b97fa6581e692f | 8c9e95fcc0009636 + v_arg3 = 53f16744cbb68235 | d7ba51f2bdfa0b66 + v_result = 8080807f7f7f8080 | 7f7f7f7f80808080 + r_arg1 = e91cea4f02f0e4c7 + r_arg2 = 9a4ac775b4b9578a + r_arg3 = fb0683eea02abce2 + r_result = 0000000000000000 +insn vpkshs: + v_arg1 = bdb9281a140bf6cb | c055838027725afe + v_arg2 = 634ac61529c11f38 | 0c8487ff29b5fd85 + v_arg3 = 287cd2a2a0758110 | e6fbe7602a59d1e1 + v_result = 807f7f8080807f7f | 7f807f7f7f807f80 + r_arg1 = 1953e47605b2a6e1 + r_arg2 = a021a700f4b31e5e + r_arg3 = 3b57d83e848151f1 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = 38809cb37a6357e5 | a48159e341dcc06e + v_arg2 = 1c1ed54ce5481ba5 | 3a40cc410c40a7a6 + v_arg3 = 62212e14838c3868 | 7b06e4d4fde0f782 + v_result = 7f807f7f807f7f80 | 7f80807f7f807f80 + r_arg1 = 00d6fd5749a5679e + r_arg2 = 73b20225264ed24d + r_arg3 = 43c05aa64fb2780f + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = b022ac476a2fd8b8 | e19eb00a5c503d75 + v_arg2 = 6fe89fae603ddc07 | eca71c72712c3957 + v_arg3 = 6f91bd5773442fea | 562bd0daed56ada5 + v_result = 80807f8080807f7f | 7f807f80807f7f7f + r_arg1 = b2038a0fd39f26e9 + r_arg2 = 3bba3490c39adaaf + r_arg3 = 0f1a2a20b2d1bfc4 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = bde6781bf1adc2d5 | 2752acc8fc4a8115 + v_arg2 = e56b0e5a531a368e | 3e57e7c008b06eb6 + v_arg3 = c10a3368d351c861 | 020665fcd4adbb82 + v_result = 807f80807f808080 | 807f7f7f7f807f7f + r_arg1 = 058618b7cfa37a8b + r_arg2 = a5038ea72e9bf37b + r_arg3 = e60f2221039bc8f5 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = c15f52704148f4af | ac4e66ac8a348fed + v_arg2 = 4838c2ef1e0615c5 | 53801397e671d7fd + v_arg3 = 91197c403198fa76 | 8b41568273c73bf1 + v_result = 807f7f80807f8080 | 7f807f7f7f7f8080 + r_arg1 = 591b27284ea351ea + r_arg2 = a62618516d00ef07 + r_arg3 = 0fd48d5d013f0ba5 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = a1308347755ba353 | ec14afc3142483f9 + v_arg2 = 6b6dd14885973858 | 129ebc6146439945 + v_arg3 = 9b577a97fce91170 | 46560a3231346326 + v_result = 80807f8080807f80 | 7f80807f7f807f80 + r_arg1 = 5148f0b6073eadcc + r_arg2 = 384a50b1eee577c5 + r_arg3 = 9deff1868e1798b4 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = 8aca0d1e4beb1830 | 69b1cc5b10a14d54 + v_arg2 = e67686407390f7d1 | ea3bf34549e73246 + v_arg3 = e52dc5a34cc470f3 | 8d495e0fdcf13974 + v_result = 807f7f7f7f807f7f | 80807f8080807f7f + r_arg1 = 972621f717816614 + r_arg2 = 1ce2eaea4497ca05 + r_arg3 = 25f1c60d746ed2a2 + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = ae2b64b0e86f76cf | 6c8138bc1a5d75f8 + v_arg2 = d7ce226ebba2fe54 | 8fb081ebb7cc3414 + v_arg3 = 799369d99e174fc3 | 8070671c682a5d0c + v_result = 807f807f7f7f7f7f | 807f80808080807f + r_arg1 = 9d179c7cc1a8ec83 + r_arg2 = 97718edce84f7db8 + r_arg3 = 833c3dde213b354b + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = 059f35b7988b729b | c3f166f0b1fad67b + v_arg2 = a3be9ee8d32e1069 | bbe4a235bdd109e2 + v_arg3 = 26cbacaa96fc7e81 | c62d2e19acf7c4bd + v_result = 7f7f807f807f8080 | 8080807f8080807f + r_arg1 = 57903c9530dd0377 + r_arg2 = 36489de4f9f4392a + r_arg3 = 99bcfa266ce312ab + r_result = 0000000000000003 +insn vpkshs: + v_arg1 = 0d8220ac8ccf1999 | 82377d7bfec863d2 + v_arg2 = b31b68029700c6b1 | ee0aca05ad00aec1 + v_arg3 = 432ac746bd7e216b | 4bb17342292078b4 + v_result = 7f7f807f807f807f | 807f808080808080 + r_arg1 = 03cf901130f685ad + r_arg2 = 8a45ed9ffddc81c6 + r_arg3 = 10b0da104ffa4e9a + r_result = 0000000000000003 +insn vpksf: + v_arg1 = 8afa7e849b7b8e2f | c21a1b218e84e610 + v_arg2 = 390b220f0d144dae | 2f6564fcc2527961 + v_arg3 = 6dcea85a4154721e | 00ba6c16c3dc593c + v_result = 8000800080008000 | 7fff7fff7fff8000 + r_arg1 = e2a49efaf9392301 + r_arg2 = ed9489a69e8a6ad4 + r_arg3 = 1561af82ab01278f + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 48bf1c73023dc9df | 65af13a61419bc27 + v_arg2 = e9bf671d1b532c7f | c9068f38da70d3cd + v_arg3 = 4567b7d4b8a38256 | 9f54830d858cdf7d + v_result = 7fff7fff7fff7fff | 80007fff80008000 + r_arg1 = fd2ba15ae51a252b + r_arg2 = 3c7073526e6f613d + r_arg3 = 1ee8ffe20727f05f + r_result = 0000000000000000 +insn vpksf: + v_arg1 = d5d6feab24ef5a0b | d1182f8829619ba4 + v_arg2 = c03886bc5356fc9f | 108ae0143a6fff31 + v_arg3 = 33f08e9ddebff9ac | 659a1c5f6283d740 + v_result = 80007fff80007fff | 80007fff7fff7fff + r_arg1 = e18ecdfb36fb2682 + r_arg2 = 9be26277a4ace944 + r_arg3 = a3eccad6520ad0fe + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 48501d1c4c5c25b2 | b146efc50de44d76 + v_arg2 = c10546b6a9202fac | 1ae023eb4e92d296 + v_arg3 = 2676c05c52e8d255 | d6754cc2efc022a8 + v_result = 7fff7fff80007fff | 800080007fff7fff + r_arg1 = 63c60722d2eadabc + r_arg2 = 357f852bdecd5b4c + r_arg3 = e66041fe9d76883b + r_result = 0000000000000000 +insn vpksf: + v_arg1 = fd0e2a3567fb2530 | b9b7499a639673a6 + v_arg2 = b302a0d737e6cb1c | 87001ad4670a7aa3 + v_arg3 = 53cf94385e1021e8 | 7d5aa42b2bb17af9 + v_result = 80007fff80007fff | 80007fff80007fff + r_arg1 = 5e59ae520664c8ab + r_arg2 = fa2c3e7fde8ea598 + r_arg3 = ad4790bbe2242b87 + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 577f4aa0cab12900 | 5f376840f99b431e + v_arg2 = e51989a500c92c08 | 3ab33c657cb8385c + v_arg3 = f262c795ad92ce17 | aa0ee58a39f02d54 + v_result = 7fff80007fff8000 | 80007fff7fff7fff + r_arg1 = 711c550e47171100 + r_arg2 = 60dde9434d980c04 + r_arg3 = 037296eac17be4ae + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 7d5fd808f3919a7c | a2a16db07e054a65 + v_arg2 = eb03a627ab99c6e4 | 1e517872eae826e5 + v_arg3 = 05e44ed513fb5873 | 3265ca912008e077 + v_result = 7fff800080007fff | 800080007fff8000 + r_arg1 = c2f18695ed9a280a + r_arg2 = 235093c57c43ead0 + r_arg3 = fb3ea8a73e50b49a + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 1e7827d5409e349a | c79d315f4a932c60 + v_arg2 = 600616a04493e143 | e27cf1cd3516f23f + v_arg3 = 1117121749c3932c | 33fdc26d92304d7f + v_result = 7fff7fff80007fff | 7fff7fff80007fff + r_arg1 = be8982a6f7359876 + r_arg2 = 06d4c3911e557154 + r_arg3 = 6d59520d85a83116 + r_result = 0000000000000000 +insn vpksf: + v_arg1 = 2e633eecba86c9af | 186302001b736011 + v_arg2 = a2b72d5300225c97 | bee8c007c5aba108 + v_arg3 = e38bb3f9ae136acd | ce05b389a30d06a8 + v_result = 7fff80007fff7fff | 80007fff80008000 + r_arg1 = d721fc3cca9ec20e + r_arg2 = 900736310fc067cb + r_arg3 = b77e16f3a6744987 + r_result = 0000000000000000 +insn vpksf: + v_arg1 = a7469b73ce67022f | a4756248d3fff55a + v_arg2 = 99b83340f6a06bed | 2d15b62caabf4e3e + v_arg3 = 4c60465808809e02 | ecfbb8518d72310a + v_result = 8000800080008000 | 800080007fff8000 + r_arg1 = 4548e252f2b99d7d + r_arg2 = d0929bec1166e90c + r_arg3 = 7e332cb05a52fdb3 + r_result = 0000000000000000 +insn vpksfs: + v_arg1 = 4996f18a0e8d1e69 | 0367cca43b8250ba + v_arg2 = 717a2ae4e71459b3 | b112178959d8e9fb + v_arg3 = e601180e41cc8654 | fb68e4eb74224b5d + v_result = 7fff7fff7fff7fff | 7fff800080007fff + r_arg1 = c696159fe0557408 + r_arg2 = 19ee5c8a8ad7294a + r_arg3 = 6c9041d7bd51277d + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 5bd5ea11f531b14e | 0f996f03c4f3ec0d + v_arg2 = 5bfa86fcf7f54875 | 923a61696da8f939 + v_arg3 = cee969b12babcde9 | afa5fefe1c8be6b5 + v_result = 7fff80007fff8000 | 7fff800080007fff + r_arg1 = 5f742c59abf4ac56 + r_arg2 = c721550d480f30da + r_arg3 = f0f939f912ac35a5 + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 6853e667a139662a | acfaf19141b6194e + v_arg2 = 5186f34172e4ec9a | a0f903d268d15b8d + v_arg3 = 696132593e7a3848 | c198446eb58b6b45 + v_result = 7fff800080007fff | 7fff7fff80007fff + r_arg1 = 19d936f4d0837c27 + r_arg2 = f9809a773e3c9dec + r_arg3 = 01e1ed68838ced8a + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 04f0bb2897fdbe67 | 82c52e78ae61bf57 + v_arg2 = d078132c8874542a | ed87274a70a201ee + v_arg3 = 203ee05a55085e12 | b3762a1c902ed91d + v_result = 7fff800080008000 | 8000800080007fff + r_arg1 = c50975e3f31cb31f + r_arg2 = 566d36894575644f + r_arg3 = dc88eef1dfc928eb + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 85d773ec83ffd04f | be46f8a0ed73189e + v_arg2 = 9cf93db112e3a289 | 95aa699712dab56f + v_arg3 = 24a5170475506fc8 | 8b8118a9e76c85ef + v_result = 8000800080008000 | 80007fff80007fff + r_arg1 = b95724549cca777b + r_arg2 = c919e881dd82912f + r_arg3 = c2bd41a05aa897a0 + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = cb43120df6b008c9 | d595d56e841d7af8 + v_arg2 = 80be40064ce1ce3b | 77779e790363d4ff + v_arg3 = 2bc97168873bee8a | 94c92f339aeed8c4 + v_result = 8000800080008000 | 80007fff7fff7fff + r_arg1 = 92e333f7fb4301d8 + r_arg2 = 4641e5dae99903d9 + r_arg3 = bb9c227f519d8164 + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = f93c4e612730e91a | 4258c48762fd0b58 + v_arg2 = 0ccc1f5c994768a1 | f9108f71db17132e + v_arg3 = 31aa3d14196177d5 | 21ee0515edc815ca + v_result = 80007fff7fff7fff | 7fff800080008000 + r_arg1 = f05c06b7a5ae62f2 + r_arg2 = 83f3990f771d3274 + r_arg3 = 564fc1550409838d + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 3a5955fab40dcca5 | 4484f88d97dc8b90 + v_arg2 = 5636d3a343e053ba | c865bc7cd97d3ee9 + v_arg3 = 38d641d521c77b43 | 4adb65a94c3f1109 + v_result = 7fff80007fff8000 | 7fff7fff80008000 + r_arg1 = 3dbd3a7d555d4261 + r_arg2 = c04966577660eac9 + r_arg3 = 67ce08695bfc50d1 + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 7e7e8cec5e029eaa | a11b9ce020750f0d + v_arg2 = badc0d4939228ce1 | 96f61ad6a28bf43b + v_arg3 = 092b7973bba1ff4d | ae8b11070883f928 + v_result = 7fff7fff80007fff | 80007fff80008000 + r_arg1 = 671261f2ad939c5c + r_arg2 = 802b64687f610efb + r_arg3 = c8a1543fa2f36f01 + r_result = 0000000000000003 +insn vpksfs: + v_arg1 = 3a9e4a06d1b8a608 | 66ed8e5c9930c19d + v_arg2 = 9a2cf1facff4e194 | db8ed6ba02646d0d + v_arg3 = f292d677e710620b | 30c680c61774102b + v_result = 7fff80007fff8000 | 8000800080007fff + r_arg1 = a233c13cf33e8379 + r_arg2 = 4d1020368d8d564d + r_arg3 = 1a9c38594e9901d0 + r_result = 0000000000000003 +insn vpksg: + v_arg1 = 2c79a2965a873dfd | a45a252009e1a12c + v_arg2 = 1fe4dc608268bb29 | 95081020aa1a36e6 + v_arg3 = 87c300e64ce414f1 | bae3a0b9d8606f36 + v_result = 7fffffff80000000 | 7fffffff80000000 + r_arg1 = 28861abfd4bce16a + r_arg2 = 79bc5eb3c58012e2 + r_arg3 = 82a13ef6b687788b + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 155e1727af3495e4 | 350cec439a8d4781 + v_arg2 = f7cd20e3b281d599 | 090ca17cf16cf0aa + v_arg3 = 62061506f8596092 | fd8696b2cdc2c449 + v_result = 7fffffff7fffffff | 800000007fffffff + r_arg1 = fac05ddc259933c0 + r_arg2 = d802d79030c4e676 + r_arg3 = 6d60a6d5db0761e1 + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 7ee86645abb374f5 | 76c0659f5f24a004 + v_arg2 = 157fc46867ed0338 | 80d1d6849587155e + v_arg3 = e3ef68171edc235f | 30627a4260031304 + v_result = 7fffffff7fffffff | 7fffffff80000000 + r_arg1 = 9da376b49e4d4fa9 + r_arg2 = 8882fcf97c8f8c29 + r_arg3 = 4c1926f121cb1c9c + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 75c340360fe5f607 | 0cfdc88a0d46ad79 + v_arg2 = 752245140dcaed79 | 0cdb33e977c7b3e0 + v_arg3 = f1204319d7c69367 | cdf71c75a03b7964 + v_result = 7fffffff7fffffff | 7fffffff7fffffff + r_arg1 = ddbf04e49e001fb4 + r_arg2 = aa6bb25cbf889633 + r_arg3 = 5957a84414b99f64 + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 4d670dc143594f4f | a0dac196c30148c5 + v_arg2 = d62a58093963d1ae | 41bd321b63762fb1 + v_arg3 = b709a68be31efa17 | 5853c39802efe583 + v_result = 7fffffff80000000 | 800000007fffffff + r_arg1 = 8e331c49ea49648b + r_arg2 = 2738142135812aaf + r_arg3 = 51b4108724a23781 + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 62d9abea140e8720 | a3bb3657c390dfa7 + v_arg2 = 7f18a62662f245c4 | fcd70208c68a03ae + v_arg3 = 69aa0729665a79fa | 19d3e9f521d3de5a + v_result = 7fffffff80000000 | 7fffffff80000000 + r_arg1 = 466c0abc6fe974b7 + r_arg2 = 6c753571fe3cc454 + r_arg3 = 389af4ef6a054898 + r_result = 0000000000000000 +insn vpksg: + v_arg1 = d3702eb2752d3cac | 0b13ff1b361c377e + v_arg2 = fb3f8fcaa95ff309 | 201749db766981d1 + v_arg3 = fd4d11abab1dc779 | dde200947e874080 + v_result = 800000007fffffff | 800000007fffffff + r_arg1 = 25e410d5fc93fd5e + r_arg2 = 2e79dcf2e129f835 + r_arg3 = 19ff62f062cf096c + r_result = 0000000000000000 +insn vpksg: + v_arg1 = 468d9eda3fd264c0 | 1422adb2ed7d2b08 + v_arg2 = dd7be89092fe5ce8 | 54bae2c06ea88ff4 + v_arg3 = f34f668ce4f8ef9a | b9b831fa415dffeb + v_result = 7fffffff7fffffff | 800000007fffffff + r_arg1 = 8ee326ab09a7c006 + r_arg2 = 282c47870c252e87 + r_arg3 = c4279ffcaf1c499d + r_result = 0000000000000000 +insn vpksg: + v_arg1 = a860bda0f1c30a8b | 01b645261bf86b1f + v_arg2 = 7dfabd13c95397aa | c70ba09e8fc66a8c + v_arg3 = 0ed75dbfe92c16c4 | c71a18ecf610e3ad + v_result = 800000007fffffff | 7fffffff80000000 + r_arg1 = ec40b99173f05752 + r_arg2 = d8c2e914d23b655a + r_arg3 = 8f65e243dbf52d6a + r_result = 0000000000000000 +insn vpksg: + v_arg1 = eba8be7f70360d56 | d9ed02831d003e7d + v_arg2 = baf611a9dfd10f36 | ed210bda62f46470 + v_arg3 = 199cc47af6653378 | e81f892c518d4bb7 + v_result = 8000000080000000 | 8000000080000000 + r_arg1 = 6f1f6cd93e6cf0c2 + r_arg2 = 477c2c366d66f15c + r_arg3 = 16d91e741513f072 + r_result = 0000000000000000 +insn vpksgs: + v_arg1 = c7720ff1c88ee44c | 2bef168f32f84178 + v_arg2 = b7779a2a0b9549d1 | 40a41e19d1cfa692 + v_arg3 = a3a2a0ed6e7fd517 | 81e84f3aecadeb98 + v_result = 800000007fffffff | 800000007fffffff + r_arg1 = cdb3db9352031176 + r_arg2 = bf6d300dba4b3e9c + r_arg3 = fc31b679f299a26d + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = 7bd8112feb1c5d32 | cbb76a9144ee26c5 + v_arg2 = 9e1386aaea2d9cdd | 018810fcf222efc4 + v_arg3 = c4fce90a9a43e2a1 | 3f65e91305f78f3d + v_result = 7fffffff80000000 | 800000007fffffff + r_arg1 = 02fb544d3f4c53ea + r_arg2 = 93318af500018b44 + r_arg3 = a86a473d2ddceaf6 + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = 89c2dced6ee15a2d | 93ca5a0d9e617637 + v_arg2 = 61b039393f56f89c | f5ce08e4bda75373 + v_arg3 = d6894f3e6b2a5373 | d3154cf34160d6b1 + v_result = 8000000080000000 | 7fffffff80000000 + r_arg1 = 10889cd3fa4e27ba + r_arg2 = dab60747a9ccaf5c + r_arg3 = 088f6268671ec543 + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = 7ea6fc214f499382 | 23fc7b84b4fa5080 + v_arg2 = 74400ca9b4b8a0ec | 2849e7afd1c5fe6d + v_arg3 = 3ebaf9353417f907 | b7c5a4156c0df8dc + v_result = 7fffffff7fffffff | 7fffffff7fffffff + r_arg1 = c034b1ef9e3c945e + r_arg2 = 35f5671b08dcd88c + r_arg3 = 52784f20e84c45e9 + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = a84a37bdb2f05850 | a2315637df5529ed + v_arg2 = 9583104698aaf00b | ae5503783453ef9d + v_arg3 = 21494198721f3bb6 | e84e1370370f8147 + v_result = 8000000080000000 | 8000000080000000 + r_arg1 = 5fea83292d37f7ee + r_arg2 = 85b82308121148d9 + r_arg3 = bf8accc85cc6549c + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = de80456f9f5f4c56 | 7b182be31fb88a2d + v_arg2 = 85c7ca9e9ff31953 | 5e9fe75a1052becc + v_arg3 = 300179d18543d678 | ab5a717af82414d5 + v_result = 800000007fffffff | 800000007fffffff + r_arg1 = 8364b9864d0ec2dd + r_arg2 = b75529e126b81766 + r_arg3 = 4f7cccc398166fec + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = 3de89766c6ce2bb2 | 22f0af85d8d8d609 + v_arg2 = cca9f639a686e0fe | 95e3142b77b55761 + v_arg3 = 5d7ca9c474339da1 | 491f0be76e7b298a + v_result = 7fffffff7fffffff | 8000000080000000 + r_arg1 = c4e7734b0cff3fc0 + r_arg2 = 79709b78c64ef533 + r_arg3 = 890e3a3153b66b07 + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = e5b0110e3ce3869f | cd46cf16959a022b + v_arg2 = 7ad445606e4363e1 | faa8c343201bbd20 + v_arg3 = a4de5095ad0c37a4 | d321646a7c6fd046 + v_result = 8000000080000000 | 7fffffff80000000 + r_arg1 = 840703ba9d764b07 + r_arg2 = 02bb945c5c3ae6e0 + r_arg3 = 38d2b4afeece347c + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = c155d1d13d708234 | 3cb36b4fc9cf5bda + v_arg2 = e1bf1fd95cbcd533 | 3505a2362891c9ed + v_arg3 = c39e1f68c319e5d2 | dff2f872ea496d89 + v_result = 800000007fffffff | 800000007fffffff + r_arg1 = a968b3d219cb1cc1 + r_arg2 = ceb8e39df6960469 + r_arg3 = 2fe751192df28af4 + r_result = 0000000000000003 +insn vpksgs: + v_arg1 = 3d61e6d7e8379e2a | 72a11c6489f544bb + v_arg2 = 5c7262a740ec3d47 | b65d9394d354e989 + v_arg3 = 033cc21b3094391a | 49f4f5ec28017a30 + v_result = 7fffffff7fffffff | 7fffffff80000000 + r_arg1 = 5e7983123f07fb5b + r_arg2 = 6074ce860be641ea + r_arg3 = 07b75c4afce6c3fa + r_result = 0000000000000003 +insn vpklsh: + v_arg1 = 0e2e1ac606a86a96 | 7a06efcb54fbf690 + v_arg2 = 0c4021ce0bff3c4c | 752571ae4a8be152 + v_arg3 = ee0a970c1164e0c9 | f31400060bfd4935 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = d639e835349f0b5f + r_arg2 = ff4cd16134dd225b + r_arg3 = dcbf17d92c5c8cb3 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = eea0a981c49f51a9 | 242528f5ccfc3efb + v_arg2 = 968c660b9810c512 | ad9bcc535b108e06 + v_arg3 = 17e675d8eddf5a4a | 868ff7e88dcec071 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 09f48ff645350138 + r_arg2 = 7aab5d36f41e8653 + r_arg3 = 144679dd34b3a8a5 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 5eee08eb75295076 | c55300127b01433a + v_arg2 = e788f19f65e5e3c6 | a090a88d3c279f7f + v_arg3 = d6fd68196f88bde5 | 30b0a97c92f91b5b + v_result = ffffffffff12ffff | ffffffffffffffff + r_arg1 = 760619cca15debeb + r_arg2 = e5c89a8a72f75dc8 + r_arg3 = 1922f1a8f1b8b072 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 6358a0a3523fbdaa | fbae68d08fc23feb + v_arg2 = f1f0f80357b376b4 | 571e426748435a76 + v_arg3 = 0988702527d17783 | 658ea0269faaaec9 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = e096ddad2054eade + r_arg2 = 5a6b26223a2672cb + r_arg3 = 1a79228e6668d29c + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 49f091c83a880354 | 67e6c51b9f6442c8 + v_arg2 = 6bd1e6b37adff703 | 6070cba9c1c75e43 + v_arg3 = d59145d44ed90967 | 9fd0d98aa181a1ad + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 115aa9cdffc9f894 + r_arg2 = b9a7d5bf0097234f + r_arg3 = cf7ca59e7daa9342 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 645470b5731a609d | 72f7b3dd643bf36b + v_arg2 = 95461ce7bfb9307a | 8f7f2c998dc15c9a + v_arg3 = 63ae16397f2dcdf5 | 1e6c874cad48b2d8 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 9a58815fa297a36d + r_arg2 = 699f6fe35d2224e2 + r_arg3 = 322dca66c5188ee0 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = cb7109c56739ae8f | 09ecc3be81884e0a + v_arg2 = f338b353bd410640 | bdd2c1bafaafdd4e + v_arg3 = a4c24666808ab16e | a962d4c9bab9f8b9 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 92a15f515287d069 + r_arg2 = 1644758991504070 + r_arg3 = 471958b133b53312 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 1c401e0f681418d1 | 629c3de33d3b673a + v_arg2 = 0e1d39ed71e53096 | 8c3c1e8f7b3c0010 + v_arg3 = 0ec22e2cf797fab0 | 4b84a0e2693b9b1c + v_result = ffffffffffffffff | ffffffffffffff10 + r_arg1 = 5317f213fd117ae4 + r_arg2 = 7114ddef40151806 + r_arg3 = d61d494be2b7894f + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 3b8b272a6d8de068 | b56fdeb244b026ae + v_arg2 = 37b870a6fe40fd9e | 22a0ce586903392f + v_arg3 = 5d6cdfd736ae03f8 | 173040b1bea49dee + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 4127604ff91a715a + r_arg2 = f3dcd24f3596e28b + r_arg3 = 2c238fbad33decb0 + r_result = 0000000000000000 +insn vpklsh: + v_arg1 = 13a711e8d4f02076 | 04189c8a6a740af8 + v_arg2 = 44de132e6edb1316 | eaaf10d2c3491358 + v_arg3 = 5410def4f092fca2 | e6124150e5f795f7 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 838e05b0c1b61c23 + r_arg2 = 9b7576a023e32c88 + r_arg3 = dfe4d306ae18d0aa + r_result = 0000000000000000 +insn vpklshs: + v_arg1 = 543a001d1fba87fd | d55a5e8e6900e845 + v_arg2 = 512d92b370ee2a1c | 57a799f9efc6ef56 + v_arg3 = 7a4ae60d0239ade7 | 14e62397ef256e9d + v_result = ff1dffffffffffff | ffffffffffffffff + r_arg1 = c916329eb7e63837 + r_arg2 = ac89a05860bc98e0 + r_arg3 = 87a7317080857dce + r_result = 0000000000000001 +insn vpklshs: + v_arg1 = 34f50e57b752189c | f3c6c5599e7ba923 + v_arg2 = 81d5d1a1191ed6ea | a21555c8775bc4d2 + v_arg3 = dec4aa6a2c82319c | 47321fdd93cf2da7 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 0558efffe15997e9 + r_arg2 = 714d9f2ba84f9e96 + r_arg3 = 86fffe3d7bf0d28f + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = 2f5a0aa6acd1ef4f | 317ae6cad07b0f3e + v_arg2 = bb52ed61a43f3b99 | 879226f7cddbde13 + v_arg3 = d4f790d1d6febbf8 | 290fe2b5ee01a9f5 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 327bbaf7ad2ee2ae + r_arg2 = fa47f6cbe0f74e8c + r_arg3 = c18f836bbab104fa + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = c775395574bdfc31 | 27e20eb8eac3711d + v_arg2 = 6e2ef71d3312d7e1 | 0c87a3ba08c5a0bd + v_arg3 = b7ea7845ccaa544d | 2adf50b144f8524b + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 11f246a7aeaf58d6 + r_arg2 = dd081ea8d1fd0b41 + r_arg3 = 65c8c079fbd15c7e + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = 45a519ada8c8c73c | f3797ebdbc057be8 + v_arg2 = 4ec2b7798b063cd6 | 3aecdb87a6074294 + v_arg3 = a5f074c902b19bcc | 3f174321bddbec06 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = e7403ef05d158e4f + r_arg2 = f5f247b1ea595191 + r_arg3 = a4a82a2263c4fda5 + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = 77541ab7cb952b06 | fa882deebf9ff023 + v_arg2 = 15f56c5adcf9d4ab | e30311ce49bc9439 + v_arg3 = 466c8e1c512d8544 | a6f54ad3298351e3 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 40b6002fd94a2d68 + r_arg2 = 27f11810ff707178 + r_arg3 = 767b6d203e2e9cd7 + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = 70b964f903711b84 | a5e489a0cf606972 + v_arg2 = 43fa87a278f79c72 | 5b217ec17aedbaea + v_arg3 = 868f867d39e61ce2 | a0496bd3bd3632be + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = b0326301a8a0b88b + r_arg2 = 19446bf00dd550ce + r_arg3 = 599d2bebbda1461c + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = 4c9b9537de1c61c9 | 25b33723ef431356 + v_arg2 = df1474f097f9ead8 | 4064130d6951ee45 + v_arg3 = 561791689e1040f1 | 362fe22bd466d74f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 8ee072ff749d4401 + r_arg2 = f9341239f40b2c0a + r_arg3 = 1134bc7ab75d1ed9 + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = ea0f80330f815ac7 | 3126cf89093275ee + v_arg2 = 345451631aa628eb | 337c349eac0f4204 + v_arg3 = 70101c558c10699a | f5d1e0a3af75dbee + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = b8fb2f81cfb23eb0 + r_arg2 = 3dda96513c415801 + r_arg3 = 6af8ed00690d1c90 + r_result = 0000000000000003 +insn vpklshs: + v_arg1 = b137ef6b2f78bc0b | c33ea15eabc329b6 + v_arg2 = 9557b556461496d6 | 9c647f5dfc7a5bc0 + v_arg3 = 1095877ef33664a3 | b2284d803673f24e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 528c515ef1fd29de + r_arg2 = 5dddf3dcd113fba7 + r_arg3 = f2eec2b0378fd0a3 + r_result = 0000000000000003 +insn vpklsf: + v_arg1 = 4c0462e07d895184 | df8a7370ccfd9e49 + v_arg2 = 1b0c6b2385850ca2 | 6a2984f4fcd338b1 + v_arg3 = bd8feb996c821232 | 48ba8748b6dda444 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 872806a9750d5eee + r_arg2 = 9b305e7bc74ed6cc + r_arg3 = c027357869ab1e11 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 6ef4cfcc9faaba3b | 4ce641878612dd20 + v_arg2 = 636b35e3292db7f6 | d2a18a87f209e96b + v_arg3 = ff73d598f3612d8a | 565c227aa15e0f80 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 47b4b374209dcb20 + r_arg2 = bdd6008e18aafcde + r_arg3 = 3084f5c7efd80136 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 90d360695fff2d1a | 593cfc2cda244153 + v_arg2 = 513d8b2b28e9d8d7 | 0c33517b8c7a59a1 + v_arg3 = 2606096fab7003cc | 02f0a6595290a951 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 0824b08f9b57b554 + r_arg2 = cea0b8f4619098ac + r_arg3 = a47427491efd498d + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = ae7c39af6f9838a8 | 9a454d656f033e56 + v_arg2 = cfd95ad0e2088967 | 1994cb319db206e4 + v_arg3 = 0a1b41cd9e3739b6 | b92754a1c7bbfc64 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 86360e48349176c6 + r_arg2 = e1ebddc9a9d5ab20 + r_arg3 = 46b329a9712d5c70 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 0e97301527357cca | a947507654eb1cbd + v_arg2 = 8fe4c5a2d70578a7 | 8186e2cbde2ac463 + v_arg3 = c653ecdf7aed8965 | ed3ee24e65936984 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 8439512aa11140d2 + r_arg2 = ce65fb261b7ccb02 + r_arg3 = c20b4b4c4968f9d5 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = fa5c934e42037382 | e7d759a0ba4abaf7 + v_arg2 = c60fe832724aaa38 | 0d9936e4ae097eab + v_arg3 = 7cdaf01356398515 | d6c43b5ab8fce759 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 89cb36c1becbd9b0 + r_arg2 = f3c992e3c876e6ba + r_arg3 = 0c15951bae60f112 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 814de70ca55f2bb2 | 3997b3e4bb774c14 + v_arg2 = efdb908fc2ed3a14 | 92eddc5ad3e4f567 + v_arg3 = 152f69d26cee53df | 3251417e31c8c12c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = a3956f544aa15e37 + r_arg2 = f59ddb576664fd0d + r_arg3 = 20f784380d30ed98 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 3bfea4bf199009d9 | ccf85cbf177a1d82 + v_arg2 = 8e5705033c741858 | a7ed200737808020 + v_arg3 = ffdb6843ddcc7078 | 064e8bf0e7765ca0 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 281062a8af20019d + r_arg2 = 7ef983141452eade + r_arg3 = be26cdc6f9252cba + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = 02cffa560c9088d3 | d1f7cbeef2c94fca + v_arg2 = ebdec1d97b93cbfd | 6a144581ad8dcafc + v_arg3 = ed37b50d71446ef7 | 5bb2272258f3ef79 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 7142eec2b848cb33 + r_arg2 = fd416eae147b1ced + r_arg3 = 2b241aa5ea774265 + r_result = 0000000000000000 +insn vpklsf: + v_arg1 = baaf8ffb54c3f89b | 42e2ab2a98079656 + v_arg2 = d4dc371901eb3099 | 40ab41e0aa6c9882 + v_arg3 = 9b298e145433b78e | 02c15a88255c4a57 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 9e8027a459435b2c + r_arg2 = 69e87574900b569a + r_arg3 = f341c932010fdae8 + r_result = 0000000000000000 +insn vpklsfs: + v_arg1 = 0bd93fd9edbc410b | 9c139eeb39c6012d + v_arg2 = 5c898e49f4cc3921 | 928782770de98153 + v_arg3 = 88e66639daa5484e | 51ce5c50d9b8907a + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 562c160d6b2ba556 + r_arg2 = ff2e293457d774a1 + r_arg3 = aa5db009c34176ac + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 2299dbd7b6fe9e99 | a3b3fc28ae45b2b3 + v_arg2 = 9fab632de2f2b0a8 | 91cdac98d8ffb5f0 + v_arg3 = bbb0a81d3d9276e6 | e4f91d2aa3c1fd7e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 84767b3c6dc7b5de + r_arg2 = ffe28ffa9e2526dd + r_arg3 = a6a3dcc5da922afc + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 7407eb5d39b7621a | 227792143331a16d + v_arg2 = 7c578b867d4bf21f | f3b05954f49ab77a + v_arg3 = 7f9772dd5aa3ad63 | 5ef10400189ba11f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 1c1e8bac454d6a0e + r_arg2 = 7420e2cfbf69b308 + r_arg3 = c74e4dbdd87265bd + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 7cc96e0d6185b681 | a96463e12b675eb9 + v_arg2 = 59afcfd460adb415 | b430d837f14e246b + v_arg3 = 273b5bd678ed2cf0 | 26b1abbef49924f5 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = d42fb2d8fd203c11 + r_arg2 = ea11557dfd04b878 + r_arg3 = 3066bdc8f402a934 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 78d4958a423459a0 | 4e8d6b7fe0aecc99 + v_arg2 = e3a3af17c9a3c277 | d6dbef0ec5246a60 + v_arg3 = cb872d6202b2cb95 | 2b45a40ad6fd8137 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ebc452f68892f7ac + r_arg2 = 36b0cf483f05e8e3 + r_arg3 = 0c8257f8cbce4fc6 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 312a8c33d57c60e4 | 6dd2575c4180e868 + v_arg2 = ccb320885d20bb51 | 228f99a3894d92d1 + v_arg3 = 0a76ac974926b6fb | a185380b07b7cb7b + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = e6c583be7ba27e05 + r_arg2 = 3282aeb5d2ebca1a + r_arg3 = 4a868061219144b2 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = b19b31e7b9c6f51c | 68a14f24a3c080a1 + v_arg2 = 8caa4e63e948d889 | e635c97e40ebf7d6 + v_arg3 = c6d04e0d44263025 | c2d723243425ec73 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 4fa9d224d5bd895f + r_arg2 = 7f5c854628607fd0 + r_arg3 = 626592d29ef6cfd7 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 0a87dbc1f4e61831 | 68b8ad818084fd9d + v_arg2 = 21635c9f1c2ca3a9 | b68526a590cd0ce3 + v_arg3 = ecec02974f015237 | 8ff05ab92fd061b0 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 76340318b78068da + r_arg2 = 4220de3a9bfe7953 + r_arg3 = 0fdf9c9892544974 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 169815dcb1e162ed | 1be0c4da3ccb1a54 + v_arg2 = d08620b34e8dc095 | 2cc7ce5b88321b8b + v_arg3 = 2a6eea07f031ca31 | 8d92c6e7b3330061 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 3039cf4c2d72bf36 + r_arg2 = e87ef94f2b0c454f + r_arg3 = 13432441b270e4e1 + r_result = 0000000000000003 +insn vpklsfs: + v_arg1 = 328b610f00a7bdb7 | 74b19a17db46ab1a + v_arg2 = e24ae8523c97a84f | a88f14e35983013f + v_arg3 = b80922ed8e219db3 | 884d064f1e76b312 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 9b58a7ece4cd488f + r_arg2 = e2b68b823c404391 + r_arg3 = f72ce655d93e6659 + r_result = 0000000000000003 +insn vpklsg: + v_arg1 = 03e7f6b099d82d54 | 6f53af5acd125862 + v_arg2 = 6833382dcaa769b8 | 117f433d1d1cf40e + v_arg3 = 103d775738e8e5ba | 544031cb362d3b70 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = d8c07065f3349521 + r_arg2 = 6a5381cd5a7d69c0 + r_arg3 = c846931ec99febb2 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 32c383549a828ba6 | cb3ab5c5a37a5f7e + v_arg2 = f9d48ab6c0046851 | 920759e693033e65 + v_arg3 = b6183092650b9460 | 87d89235e51dee03 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = cfec4522937ccc04 + r_arg2 = 3defbbe6f6950524 + r_arg3 = dc089460e823a721 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 3083eb8b45df456f | cfe7563ad8b9565b + v_arg2 = 6f8d0cda8ea71ff4 | 5f26cd9ae1ae00cf + v_arg3 = f1f7c9e6af3e309e | 418f6c25fdf67af1 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = f0683949e76769ef + r_arg2 = 5ff4d30526067862 + r_arg3 = 8b7ac52003c6a2f9 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = f39a07a7c41a200d | 06adf11489b4e747 + v_arg2 = ae4c66c509f6e09e | 6e294a1451c0f1b5 + v_arg3 = 9145b45b9722950b | e5adb4b2f518a0c0 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ed8b1381b66300f7 + r_arg2 = db58d49d69bffc3d + r_arg3 = f7f03a5f0fb57a6c + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = b7486875e50af73e | 03685ef23ec393ae + v_arg2 = 5d4e73a12c839128 | 3f6a71cb16cb1c1e + v_arg3 = a83a17794506b79d | de09da2faa51fa13 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 823d10ad2c4ef950 + r_arg2 = 815f032162db5f55 + r_arg3 = c6ccfedee4092548 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = bf5b1200def47add | 1e46a66b9f6771d7 + v_arg2 = abde0455d9d06f08 | 95119bb6050da66e + v_arg3 = 519b910245a95e66 | 5cc781ee209bb66a + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 2db2a5b09d33530a + r_arg2 = a75c9abf9964c6ea + r_arg3 = e33ecfdb0189aeb9 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 12f142540b4cf0a1 | 3681ccd94013eda9 + v_arg2 = 0c13a149960dcc13 | 3ad596075d358629 + v_arg3 = 6d7ff6b94cf4e957 | 151a42ff3fe15ae5 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = f72b3c2a420c62d4 + r_arg2 = e96f88263e106c98 + r_arg3 = 4105e4d04c6af40b + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 3f322a37ac72f6e3 | 6e21881157e6896b + v_arg2 = fa95481e51d7d13c | c0ba64f2801e4baf + v_arg3 = 61070f1df1c30dff | 04016ef098ba7f01 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 2abbf238fa8192ba + r_arg2 = ea463343e506611a + r_arg3 = 982ea83acf116e68 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 1a19b1f0a8783e57 | f0bc0728816e9f7e + v_arg2 = b6582c791cf93d54 | 3cd30066b892db01 + v_arg3 = da235b2d759c934b | 2e0dca8d1e2b9657 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 18fe60370ba622e9 + r_arg2 = 11de37fe4b984c0a + r_arg3 = 26d37d4e7ccfea95 + r_result = 0000000000000000 +insn vpklsg: + v_arg1 = 7d2a34024dd951d1 | ae38ad2e81651e24 + v_arg2 = 055d78b8f22e24ca | 09ff1ad1f3072f79 + v_arg3 = 8952d1257c751d46 | 591851a0ed67a663 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = dbe25080e0bfe968 + r_arg2 = 4c42250010082a9e + r_arg3 = 70dc7ac4eaa24ab8 + r_result = 0000000000000000 +insn vpklsgs: + v_arg1 = 083c48f10e424e00 | 1c87d4f40176493b + v_arg2 = f3770aba71dbb26b | 8baed6de87631894 + v_arg3 = e8619d3dd271e2d9 | d30df6b006910c39 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 1160832bc9fe15e0 + r_arg2 = d14a466e7c460d6c + r_arg3 = 00bf2e8f16f94613 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = e23076fb454baa34 | f8698bc950f87c01 + v_arg2 = 9402389a9fd7e622 | ea9d9139f0bbfdaa + v_arg3 = f429df6f28a16e8a | 32a660c512773a4f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 9c4272cfbf42e854 + r_arg2 = d95b56ae3cafdf25 + r_arg3 = 25425ca1246f2ec8 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 76b6fddeef3dee1b | 032c583723b0e8d0 + v_arg2 = beab8f72a62558b8 | d3949d488e0e9bb3 + v_arg3 = f2546f31d5c5643f | 0e28ad211b587a39 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 68de0a3e1dd97be7 + r_arg2 = 642c492022ce1d5c + r_arg3 = b637bdab1c8ea596 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 380d959773cd7d7e | c56df6ca559152e2 + v_arg2 = d12e901b98b7f494 | 3c2e00f2680cc503 + v_arg3 = 2b189c35960b3cfb | c9273007579da967 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 25d8704c683d7b9b + r_arg2 = f97d09e4e91d9c3e + r_arg3 = cf3ec1d9af8c6799 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 5ec2271f5cde4c07 | 4dd718c8a77ed80d + v_arg2 = 711272ea2c2cbd7a | 1d8f395bedd4220d + v_arg3 = b0f9e92f4ece069e | 49463376dea2fde8 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 0ae2bb8809d9ef0f + r_arg2 = 63e03799eec3485a + r_arg3 = 93854f98f00f050c + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = a86e962e1a41a8fd | f0e125f88105ad86 + v_arg2 = 466ee37380928c4e | 382efca5aeb0f322 + v_arg3 = 1789cf8dc75826a8 | b9f7b6ed6f6dbf29 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 917ebe000fc4f03f + r_arg2 = 7574e71bf956e15a + r_arg3 = ea8981521beba509 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 197b7afbc677f405 | 0693fb5daf24d9a0 + v_arg2 = c3a5c849d623cfd1 | d38bf1af25daca31 + v_arg3 = 3c2a7f3f709f16f6 | 4c362e27307312b4 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 3db9bc00ee827047 + r_arg2 = c7a36543f39abdc6 + r_arg3 = 41d46a2f52e1c346 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = bcdfe0f9db6c69e1 | b140adfa2607fa8c + v_arg2 = dd2cf9ba570a4a61 | 79f87ad7713a5487 + v_arg3 = 01c99e701e092882 | fa5048de6b59abf4 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 58f031d243c9f41f + r_arg2 = 78eaf3a9ad3e89c6 + r_arg3 = 4dc0d0d45b61f2d8 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 60dd0c9afe3bd533 | 964b468fbdc60619 + v_arg2 = d0410695d31ddabc | bd536bba1824118f + v_arg3 = 0fa30749cc2a4225 | 42a1a48b52af98ee + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ae8e917d8e385b5e + r_arg2 = eb908863a0a408df + r_arg3 = c831f32764489cf2 + r_result = 0000000000000003 +insn vpklsgs: + v_arg1 = 5dca380eb8f05c39 | a2e58459f52a0775 + v_arg2 = deb5f6e77fa32ebc | f6c9d0f1c51c1792 + v_arg3 = 94038db35b83a056 | e6509b23bcb6fa08 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 54ca0189f62195fa + r_arg2 = 8b6b93c6a899d3b3 + r_arg3 = 335e4507bfa1bfa6 + r_result = 0000000000000003 +insn vsel: + v_arg1 = 4ec4530338403b91 | c6cd9dd5b268dee9 + v_arg2 = 10a202b8b70f8c1a | 0593abd50894d476 + v_arg3 = 0400b714534496eb | b313fadbe71acbc5 + v_result = 14a213a8b44b1a91 | 868199d5aa8cdef3 + r_arg1 = 646c20b7093f6d04 + r_arg2 = 87a1b623c91718c5 + r_arg3 = 93872f17a766afa1 + r_result = 0000000000000000 +insn vsel: + v_arg1 = d57bc365125181f6 | bc0dfe7c00e2019f + v_arg2 = f4335fd1bac1932e | 0bbbb43b1aaac982 + v_arg3 = d9418210a1094cd6 | 37f0c6e335b69986 + v_result = f573dfc11ac193fe | 3c0bf6780aaa4186 + r_arg1 = be87c1cc7a7e416f + r_arg2 = 96638c8aeb095c31 + r_arg3 = 34bed373fa3ed7f2 + r_result = 0000000000000000 +insn vsel: + v_arg1 = 5beb231e0377d5ff | c1c10886d0eb3e5e + v_arg2 = 5d61f27771caf4ac | 35d7183797ee5016 + v_arg3 = 53bc2348579f80e8 | 89f8f62def554948 + v_result = 5fe9f33f2357f4ec | b5c70816d0eb185e + r_arg1 = c93eaf46e3b9c5c9 + r_arg2 = b5b365889e053a76 + r_arg3 = 6aa1c577fe3f78c2 + r_result = 0000000000000000 +insn vsel: + v_arg1 = cd1f06d6abf333e5 | 5ad2d2aab983764a + v_arg2 = 27b31a3029a73867 | 71ca3adb42195776 + v_arg3 = 3971c31d70bf4990 | 060d3c25056ed66b + v_result = 0f931a3429b331e7 | 73c212fa4313575e + r_arg1 = 308268248175c4ff + r_arg2 = e51e05ebd612222f + r_arg3 = 4c1dd27e1dac681b + r_result = 0000000000000000 +insn vsel: + v_arg1 = 61eeb3b251b4af3c | 10b6eadbb81663a7 + v_arg2 = f1fc6b7c55047e10 | 368976f7c5d6247f + v_arg3 = 9632426c89d0cf9b | 0f9cbe79cce71067 + v_result = 61ee2b305594bf18 | 3095eadf8916243f + r_arg1 = a7d1e3a1fbaadf1b + r_arg2 = ef816a7cb0621bd4 + r_arg3 = 772bba9faab7d5a4 + r_result = 0000000000000000 +insn vsel: + v_arg1 = 4fc0e817a31931b7 | 3430150bf13f5396 + v_arg2 = e21f6e9b4e793af6 | 40d2dada6e7b0f6f + v_arg3 = 7d5df652aaa814f4 | cc62d5d1c0d15e97 + v_result = cf42e89be6593ab6 | 04b01f0bee3b53fe + r_arg1 = a4f84bf71c794d08 + r_arg2 = 20c683c22d18817c + r_arg3 = d295f6709a3f0062 + r_result = 0000000000000000 +insn vsel: + v_arg1 = 9948986775ac38e8 | 9c150be96c89ecd5 + v_arg2 = 65cd624d134ff7c6 | 52f5eb0ef4cf4ca0 + v_arg3 = c79e69e8fc4aaf63 | ec29d59640307df2 + v_result = a1490a65770d78e4 | 9ed52b88f4cf6cd0 + r_arg1 = 27d0c21f94f6994b + r_arg2 = 0da6fac4f302c89c + r_arg3 = 45b073c64b910378 + r_result = 0000000000000000 +insn vsel: + v_arg1 = c549adc17ee799fc | 64033ca5d92be782 + v_arg2 = ed44fe8b0a3a164b | f38e671e30c49f4b + v_arg3 = d0b11f0791a88b51 | 648ac6ae56b33fcb + v_result = ed45ed891ab29d5a | f70625b47067a782 + r_arg1 = 73031f8ebcde68ca + r_arg2 = 5168ebc60f5e39c8 + r_arg3 = 8122557141298de6 + r_result = 0000000000000000 +insn vsel: + v_arg1 = 9e54c7c41ef13d82 | af2a8eaa4ccad5d7 + v_arg2 = b2112d51bd1f8e2e | 3247fd52e53c2647 + v_arg3 = 3e1c4e042061ad81 | 2cac243d6c764d97 + v_result = 9e1567559d7f2fae | 3e6bdd6acd4a67d7 + r_arg1 = d3c6b1f850603187 + r_arg2 = 4b9fab0ab697b16f + r_arg3 = bb9cb503e471a14b + r_result = 0000000000000000 +insn vsel: + v_arg1 = f787fc4b1b5fe623 | 64061d62033addee + v_arg2 = 73cdd1569eceabb6 | 6399176f7ac713ca + v_arg3 = bbf8a473c682edd7 | 0502a36418c6e6a6 + v_result = f385f5471a4ee623 | 669b156b6203d5ee + r_arg1 = 579ffa1033d60465 + r_arg2 = e1ee838fff0765a2 + r_arg3 = 71a06489457f5ba5 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 684e973160f6eb69 | f221fbf51c3c7c7c + v_arg2 = 684e973160f6eb69 | f221fbf51c3c7c7c + v_arg3 = b6a705e6c647b813 | 370fed04d2dc9fe7 + v_result = 684e973160f6eb69 | f221fbf51c3c7c7c + r_arg1 = 941f75442f8b44e0 + r_arg2 = 40c672d3abb6a1cc + r_arg3 = 253aa74ed7d9ab0e + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 0f24d90dbe67f87b | 0dd4ee08603f4498 + v_arg2 = 0f24d90dbe67f87b | 0dd4ee08603f4498 + v_arg3 = 279e4bad4ad9d595 | 4b24637ab99f21a6 + v_result = 0f24d90dbe67f87b | 0dd4ee08603f4498 + r_arg1 = 68a75284b2766dd7 + r_arg2 = 9a25ef93df18847a + r_arg3 = 1ec9fa9e36341980 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 5152bcf5ab11d0dd | 6e063580fb229f75 + v_arg2 = 5152bcf5ab11d0dd | 6e063580fb229f75 + v_arg3 = 491b059621111d19 | d61fd8635365ef50 + v_result = 5152bcf5ab11d0dd | 6e063580fb229f75 + r_arg1 = b52635fa93fcd045 + r_arg2 = e657a689e5d2c613 + r_arg3 = 2bb7ce7fe42f8091 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 97adab3e06c10c34 | 98ea443f42ef8a22 + v_arg2 = 97adab3e06c10c34 | 98ea443f42ef8a22 + v_arg3 = 5eee39ad8032417b | 2f2c5a584bb11e2d + v_result = 97adab3e06c10c34 | 98ea443f42ef8a22 + r_arg1 = 21d8fbd1cbb15202 + r_arg2 = a5b8372bee74739f + r_arg3 = 5f3b4a78071bd336 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 125b4b38d173daff | 8fc383e46d9f5b4f + v_arg2 = 125b4b38d173daff | 8fc383e46d9f5b4f + v_arg3 = 6e3323fcc2b18973 | 3486eab131f41b23 + v_result = 125b4b38d173daff | 8fc383e46d9f5b4f + r_arg1 = dd0776f13d163185 + r_arg2 = 986efb71d33eae83 + r_arg3 = d61c0e4d2db5dc83 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = 788d36f5f610be5d | 9fa2148e5bdb7c09 + v_arg2 = 788d36f5f610be5d | 9fa2148e5bdb7c09 + v_arg3 = 0914f44b28f09059 | 09363f453d4f6978 + v_result = 788d36f5f610be5d | 9fa2148e5bdb7c09 + r_arg1 = 5bcc2cc0705ac0a4 + r_arg2 = 8b31bf8ed1de7042 + r_arg3 = 6f6fecbf09e8f867 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = c644bc01043155cc | 1b248b9851b82d7c + v_arg2 = c644bc01043155cc | 1b248b9851b82d7c + v_arg3 = 018a94df9afd0ae0 | d9d188260d4e618f + v_result = c644bc01043155cc | 1b248b9851b82d7c + r_arg1 = 17ce1de1501b2750 + r_arg2 = 0e0687b4492e463c + r_arg3 = 9156af4f348edd73 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = fd0fa12aefd90de6 | 1c38b45cbb7947ae + v_arg2 = fd0fa12aefd90de6 | 1c38b45cbb7947ae + v_arg3 = 321b613d65557fdd | 943c286862adf1a8 + v_result = fd0fa12aefd90de6 | 1c38b45cbb7947ae + r_arg1 = 50007af7f225245c + r_arg2 = 37fe4cd486f91770 + r_arg3 = e7c2d5fbed2f5592 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = e5cae238d43def25 | 3ed651f3ea4ff449 + v_arg2 = e5cae238d43def25 | 3ed651f3ea4ff449 + v_arg3 = 3a9ceee7fca60d00 | b06a78dae8155ea3 + v_result = e5cae238d43def25 | 3ed651f3ea4ff449 + r_arg1 = cd656f624d31cd36 + r_arg2 = 63fabf5a77b6dd3c + r_arg3 = 243154fddabf01d0 + r_result = 0000000000000000 +insn vll_vstl: + v_arg1 = cd5f70b4b37e579e | 68c7d9f2d51b7851 + v_arg2 = cd5f70b4b37e579e | 68c7d9f2d51b7851 + v_arg3 = 42efc61cb7872a98 | e91c88caecde02bc + v_result = cd5f70b4b37e579e | 68c7d9f2d51b7851 + r_arg1 = 99cedbff02a64caa + r_arg2 = f26905f3714a681b + r_arg3 = c16f5992c5621717 + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 4987f3a4346cb6c9 | 81623b2dd929ece8 + v_arg2 = 2e44478e276ab454 | e2d2b9081b6592f5 + v_arg3 = b4c5279b97406052 | 019edfc424ce0f4f + v_result = 5afbd2b600000000 | 0000000000000000 + r_arg1 = c79813eb1559a2a5 + r_arg2 = 0e077949efc81e65 + r_arg3 = ba5704af612a25ec + r_result = 0000000000000000 +insn vlbb: + v_arg1 = dc54259c699486f4 | 2cf786ed74711857 + v_arg2 = cd360f5e20e8b367 | 38a7b8cfaffe9289 + v_arg3 = 2aaf2e9d09650583 | 674093637f3f3135 + v_result = 018710f900000000 | 0000000000000000 + r_arg1 = 828f37526cd74b94 + r_arg2 = 2f130ed3e97983ed + r_arg3 = ebc7eb4aa3391974 + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 33b6aa03e3bc3a0a | 72957bdbf69fc2f8 + v_arg2 = 26768f9a47dfe250 | 6c9cf27d201147b6 + v_arg3 = 68d929ff2e337aec | 034eec9b46779593 + v_result = 4a6976b300000000 | 0000000000000000 + r_arg1 = 9e0c6c5e833a0e4f + r_arg2 = 373269c7d36ad9ef + r_arg3 = 8f62c4526b52ad3f + r_result = 0000000000000000 +insn vlbb: + v_arg1 = d1effd809e89bfa9 | 7e2fabfd62e44ea6 + v_arg2 = c8642d6468cfd7e8 | 333e6413be2b4012 + v_arg3 = 08bf6a619a0605a4 | 16f44f67165df8bc + v_result = 2e70c81000000000 | 0000000000000000 + r_arg1 = 2cc96c1cc5fef639 + r_arg2 = 9d8b1950df6462ca + r_arg3 = 4380b4d1734b196c + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 3fd40df7fd0dd98c | 3d07dc53e1a1b51b + v_arg2 = c76f449e302684a8 | 86ecbf0f80882394 + v_arg3 = aa6dba9f4ba6c2de | a8ac5dc2b10babe1 + v_result = 78f5715300000000 | 0000000000000000 + r_arg1 = 04d02395c4c9a594 + r_arg2 = 5d56a356251db67e + r_arg3 = e945944c17a7a979 + r_result = 0000000000000000 +insn vlbb: + v_arg1 = cc86014a8c87e04c | 256bcaa0842446ad + v_arg2 = 7ed4e9a5f7feee64 | 67902b2ec0d3694f + v_arg3 = b63a1793600d61ab | 46fca866be8654d2 + v_result = 1a82749e00000000 | 0000000000000000 + r_arg1 = 80377792f832103f + r_arg2 = ba97403f61f88169 + r_arg3 = 6a65b4881b598101 + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 4c33f61ab9268522 | ef78e822ff686613 + v_arg2 = 4d5fa11577e4ee0f | 9c63072b01e32534 + v_arg3 = 178e75d5e321eaba | c0397b878a82b1bb + v_result = ec8b28b000000000 | 0000000000000000 + r_arg1 = 45e4025b7e7d4678 + r_arg2 = fee1a1b1b9c84606 + r_arg3 = 74e09c486880597d + r_result = 0000000000000000 +insn vlbb: + v_arg1 = dad8bd8699c58ca1 | 5dda1d5470d7501f + v_arg2 = 5c282d8a938df77c | 72aca77daa7fbed2 + v_arg3 = 029f7d7d81747a1a | f245979bca2255ea + v_result = 6b35f8a700000000 | 0000000000000000 + r_arg1 = fb49d472da5b299a + r_arg2 = 3616ac4e768d1fae + r_arg3 = 3dc6c70ccf2b4206 + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 97009eeaaaaf907f | f68888b1170ad684 + v_arg2 = 57563f5c12a1d01a | 7c80151bc91ab118 + v_arg3 = ae2e51df4d0a05f5 | 7853f11458b46a86 + v_result = 7b1129be00000000 | 0000000000000000 + r_arg1 = 1128325bb5ad33de + r_arg2 = f7243e75c7347c59 + r_arg3 = 3ef267d2c5165f0f + r_result = 0000000000000000 +insn vlbb: + v_arg1 = 6984189f8c5bc34c | c58b3c721c861f91 + v_arg2 = 31de4261627356b5 | 5383d13ad1965110 + v_arg3 = 1a4d474c81121255 | 78a07622f2786e58 + v_result = 26e1940e00000000 | 0000000000000000 + r_arg1 = 7b4f5a55a040331c + r_arg2 = 1cc9e706825ae05d + r_arg3 = fad125d72669ad2e + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = 292a6746c787d2c8 | 6baa1aff8cecfff3 + v_arg2 = c4ac45127102ce87 | c04a11820d92ed4e + v_arg3 = b0ebe1521d93a1f0 | 6d050c4143e983b3 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 745b3c21d1910f8a + r_arg2 = 864eb11ce308a82c + r_arg3 = b51bde55f37fbdd3 + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = ac9d490f8a9c08ba | 9db1454b71b0ef0e + v_arg2 = 1c70470caa3cb82c | db210f335119099d + v_arg3 = 111b545f6a0adb86 | 3b8184af9c823f6c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 3c7743b9e189807b + r_arg2 = db4edad34b76c419 + r_arg3 = 3e976845149b750d + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = d0d2fccce2b19dd4 | 82a2624d672a41ba + v_arg2 = bf53523b56d25f69 | 1e1ce215114e52e7 + v_arg3 = 7d00e0daa2f0899a | bf928fc4767a4b03 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = db1c0b189541da1f + r_arg2 = 496f960202cb7d13 + r_arg3 = a6da4b1e17b3d34b + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = f2df6346465c87f7 | 5c81aa6a2dc0a355 + v_arg2 = 9409b5633bb6e6d8 | d75bb10cd97220c7 + v_arg3 = 69ea4182d595f984 | 53753ede25edab4e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = ddd229f792bec248 + r_arg2 = 4126ce01f7da2e66 + r_arg3 = 07078992f027ab17 + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = b3aa18c2d5e0d460 | 74e1ce48e5419759 + v_arg2 = 4c92f846410705f5 | dc0e98b816b32475 + v_arg3 = 90f5e997baf38ffa | 57f6199b66643a42 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 14ece78c28b4f521 + r_arg2 = 3c75e4637be40b7f + r_arg3 = 3f8f5756b88964db + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = bea52cc512f06669 | d9a3b488dbb03721 + v_arg2 = 19fd956639d4ccd5 | 47306a38e0ec2184 + v_arg3 = b3ccc1956b7488ce | f32cdf941b976aae + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 5a4f054c084508f7 + r_arg2 = 7aaf6ebc0a5cdda7 + r_arg3 = b3f1e2da6e56bf9f + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = 8091e5d1a66cb74d | 1fb7388b3df9f2a4 + v_arg2 = 7727c0c097d861ee | 384e6ee7b167b4a9 + v_arg3 = 5869e6f62bb0b5b2 | d24044210b2d0104 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 4e2a7aa80ec124f3 + r_arg2 = be31f75a039dc4c6 + r_arg3 = 0d790b0bbaba91c7 + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = ef3e8028222196e4 | 21daec2fe0b84d38 + v_arg2 = e77c2191393ebdd4 | 974023212c9d0e76 + v_arg3 = 8cd16ef3212e3cf7 | e925b21aa378de0f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 12bd32d3f967c7dd + r_arg2 = 1429c20e6bb4f520 + r_arg3 = fe032c16a54e85d8 + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = 4547ed86bb8ce861 | c055d99202f8a44f + v_arg2 = b0b495131f5d74f9 | d0edfcfdd8f3b519 + v_arg3 = a2da21421a215c48 | 2e600a92b83cb2bc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 1415ce792f2186d9 + r_arg2 = 8c5287e3af1b7a1a + r_arg3 = feb8d22763dcdc32 + r_result = 0000000000000000 +insn vlm_vstm: + v_arg1 = c2d997ea0d966819 | a2c23ccc03f0e73c + v_arg2 = 9d95f13f317b6b6b | 960a2513e37d4721 + v_arg3 = f3e741d84b2b2672 | 62c0619c4468c8d4 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = c2cc67877a4acd2c + r_arg2 = fcb434e46079f6f5 + r_arg3 = 07ce81240a182dd6 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 0d49174587e60b3b | 88f6f2f8b4bcc819 + v_arg3 = 42e522a2e67c899c | 12b22c96a092f7ff + v_result = ffffffffffffffff | c2b6bf8bffffffff + r_arg1 = 55cc4ce8ce6a9ef6 + r_arg2 = c367aed9f5665f8f + r_arg3 = 5e4a747558672520 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 91524aedd45d18c0 | c16cf101b5c4e654 + v_arg3 = 919474a659a09380 | 3ed22f5004a9fd7e + v_result = ffffffffffffffff | 3839ffabffffffff + r_arg1 = 880cc04501f74ff8 + r_arg2 = 814f8e088c24c228 + r_arg3 = 4bc05bbf729b488d + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 699fc4b7c6f0205c | e910f27d03813dc1 + v_arg3 = 31a8b96fe33fa98e | a29e0ddf33f03bbd + v_result = ffffffffffffffff | dd8ee853ffffffff + r_arg1 = 5e50bdc392144d4e + r_arg2 = e1e0e5f7aa660319 + r_arg3 = dd111ba2a0b3af75 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 1b29a51c9f36f4c1 | ad0aa9c6639893ce + v_arg3 = b438fdf593cd4ab3 | 77d9e7984169a3e8 + v_result = ffffffffffffffff | 1536a6f2ffffffff + r_arg1 = e0ebb5c76454db35 + r_arg2 = 50daf927f70b9b9d + r_arg3 = a72a9281129ec9cf + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = b4f7ff5585b6ba3d | 014d82b2455ec649 + v_arg3 = b4e6bf6bdd2cc7fb | bc9412cd6744be08 + v_result = ffffffffffffffff | 8c7c1a77ffffffff + r_arg1 = dd7f4cb48077d4c4 + r_arg2 = c30d06da04e2588b + r_arg3 = 86ca51399ff71bf3 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 86de9d1748a2b07e | db5d5c567b94891e + v_arg3 = 8fa2b5055a6d0b4f | f7edda8fc59f6bc4 + v_result = ffffffffffffffff | f23b9e0effffffff + r_arg1 = a8ba1faad72a65b5 + r_arg2 = 7614fecc05662118 + r_arg3 = 5a3b60e781c80052 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = ec41bf591a9ee950 | fc0c4ec4ff292615 + v_arg3 = 2a6c8cb28a8c5436 | f0d2436b2046a022 + v_result = ffffffffffffffff | be9ebee2ffffffff + r_arg1 = de1a8147fdcad51c + r_arg2 = a81c4afc9882b098 + r_arg3 = c817ffa61b4a6a3e + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 02d1dc0b55790e5b | a73763cdb0fd3b98 + v_arg3 = b011a6e19237f896 | 7abec32fa4732846 + v_result = ffffffffffffffff | edda00dbffffffff + r_arg1 = 1fa83968f0203e2d + r_arg2 = 609d88637c4d573c + r_arg3 = ff03604db4a2a0a7 + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 6e4c60df39f11fe8 | 688b5ebe169b7e6a + v_arg3 = 50ecda3eff862273 | 2b7a0aa4a48e6430 + v_result = ffffffffffffffff | c0f49e60ffffffff + r_arg1 = d1bf46e7d02452f9 + r_arg2 = 2b1e4bb95bcebdd4 + r_arg3 = 71756e3339a5feda + r_result = 0000000000000000 +insn vgef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 1a416c03ab72319c | cf4477251bfc7a6f + v_arg3 = 02a5387481c293ad | 1fdcbb5456ed0b80 + v_result = ffffffffffffffff | 82804715ffffffff + r_arg1 = e1c49c5da5bc1730 + r_arg2 = dcf4df3682b79e8d + r_arg3 = 96708aed0093b942 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = f8c99ae3f8d62f3b | 33eb1d8bd0494f69 + v_arg3 = 43f4c4ebb22162c4 | ba8930449893eb34 + v_result = ffffffffffffffff | 4182e43c8cd96cea + r_arg1 = 82eee5e01d7dabdf + r_arg2 = 4c02034da52c8fb2 + r_arg3 = ad45490c80de992a + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = bd4db7ea91249965 | 7117b23a2f9976b7 + v_arg3 = d55d378acd87bc96 | 63b53bbaaff3a667 + v_result = ffffffffffffffff | 9c8b2d83df781c9f + r_arg1 = ecff41c54b680232 + r_arg2 = 1878ad719c7cb76e + r_arg3 = 7a5337e31ae2bd78 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = a7468740cd54485a | aa2c53f7d3ad7c17 + v_arg3 = 81f4c2757845a61e | 4ae1e0f703ad7613 + v_result = ffffffffffffffff | 145958c48cc1c36b + r_arg1 = 1e07075e6aada331 + r_arg2 = 6797cad328e49887 + r_arg3 = 0ac7983ed4ad5c72 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 39f6848bab0828b8 | 091d8ec7c2bac364 + v_arg3 = d619cace7bdcb736 | 239a1dfbe54eeace + v_result = ffffffffffffffff | 17d1d718191ae87d + r_arg1 = 9d2682bb986a6f85 + r_arg2 = a26afc21af52c523 + r_arg3 = 6b5b222a19b77f7b + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = fa32a0b18e52fd3a | 7b2c2aad241e4458 + v_arg3 = e83bad7686b9df54 | ea3fa2474913a88f + v_result = ffffffffffffffff | 56aad515b5982764 + r_arg1 = 3349b66b9c6b5b33 + r_arg2 = 3a8d5b47fd1faa85 + r_arg3 = 7519c5b37ba9c8d5 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 3a1bff94ff732079 | 76a7e3690a275049 + v_arg3 = 12977cccf0f9234f | 9eba9a958ca52969 + v_result = ffffffffffffffff | 8a25f38ff4bcf5cb + r_arg1 = b2eb193aa1ea325e + r_arg2 = 66e9352f02d247cf + r_arg3 = 8517649f72192e5f + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = cddfbfd36f993fae | b3ab2c3929d24bee + v_arg3 = b4f9c06c74255e19 | 064461a030dc814d + v_result = ffffffffffffffff | 33d5065a8f365a3a + r_arg1 = afd45af4fa4f5508 + r_arg2 = e274ce8397e2f6c0 + r_arg3 = 3d3b9a361b4bbf57 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = ce7bb08ef39f216d | f4e4ec9a9c89701a + v_arg3 = f67936f0f2f50285 | 6f244ce29c7e14ca + v_result = ffffffffffffffff | 5457da0526a3b6da + r_arg1 = 48dc1e1fddef7bd0 + r_arg2 = b2f3216939732176 + r_arg3 = 46f776fdfaf05d18 + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 5e7a1d2006d06069 | c0494107a6e2917d + v_arg3 = 843e94b13510d602 | 6c6f654fde0062cf + v_result = ffffffffffffffff | 3919f39ffe517d30 + r_arg1 = e0a7bec328cf71b4 + r_arg2 = ddba9e45cc170d2c + r_arg3 = 0f0d4074b9e982db + r_result = 0000000000000000 +insn vgeg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 63b582e54ba32e35 | 22e341b76e65d569 + v_arg3 = 513d4284a7c9b75d | 96c92c1d6943bd66 + v_result = ffffffffffffffff | 32154874c4f9fbdf + r_arg1 = de690b241f61dbcf + r_arg2 = 336aeb795a8d93fb + r_arg3 = 8c4b32dee704fd79 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 4a1354f54a7e11ff | 6e85b561c246788a + v_arg3 = 55f822801fe25781 | 4a20587ed8570f7a + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 72a20b852c44f21a + r_arg2 = 09b0a426d284e29b + r_arg3 = f74e40f8babcb425 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = c64abde62f76a856 | fd94ddfad6258fab + v_arg3 = 4f4249b5944b0238 | 6f769462a93a9590 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 50e1bbe69e07452d + r_arg2 = f80b1bebca574022 + r_arg3 = 9341d1bfcefb6035 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 8f9b5d8c8e0b64e4 | edbf2f7402d3c276 + v_arg3 = 84f9c4f5e8e354ea | 2d9744390398a790 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 7384cbc56be579fe + r_arg2 = a28519a33ed0c6c2 + r_arg3 = 659d852ee4da55d9 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 24980bba22ef5033 | e2c6187f880f1033 + v_arg3 = 7ec9548e9f34045b | b7dd3ead718b6e7c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = db7565dff089099f + r_arg2 = 6e779b2a4fe8278e + r_arg3 = faeaeefba55d38e0 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 8ae093018abeca6b | c836ba4b4c439086 + v_arg3 = cfed330ca5399e70 | 03f1916ba55aac35 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 50ece7eeacca0703 + r_arg2 = 4748961706846a34 + r_arg3 = 247b57605d3ac778 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 0cdf766f0bc64810 | 8f2aad429a4a2b34 + v_arg3 = ccf0cefa0c1a41ea | 8e8c42d9373d793c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 1e32a56b096edab8 + r_arg2 = 622db5820f38acc3 + r_arg3 = bd3580cec19395ee + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = fa92ad5051bf15c7 | ee0abfd0e42c63dd + v_arg3 = 536789a0ccec6527 | 19300be06416016e + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = d85ba94c13eaffad + r_arg2 = f5ea17be7f07e065 + r_arg3 = 634760baaab6cb69 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 6a3f67ef2e931211 | 224eb51e82df0fc2 + v_arg3 = 86b77fc5827598e7 | 6ff31ba2d03848c5 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 160a73c63f1ec8ec + r_arg2 = 018e121e8f1f8f24 + r_arg3 = 3bf1e253d8e2e9b1 + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = fa40c7545a16760c | ad3a08d172071d80 + v_arg3 = 8ed43f6d32e53d03 | 1d33d9434522e61c + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 3830b90a261c205f + r_arg2 = 0938f3b35fa099a7 + r_arg3 = b040aa48b00383ec + r_result = 0000000000000000 +insn vscef: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 8db8a70533cc8f38 | 17a1a9cf16b54fd1 + v_arg3 = 5afe919a069c4c36 | 3861a1a37243ccea + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 21cb280a49e1468d + r_arg2 = d9d7bb0bb554f2f5 + r_arg3 = 31cece86ff74065e + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 0a5a58c87ba97f2e | b1a5bef9f92aff50 + v_arg3 = 5e852f0d0de915d7 | 1cb98620adb6fd04 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = fca92234cb198e5d + r_arg2 = 41e4e4f2bc776630 + r_arg3 = f7859ef6b5ba7128 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 2128615f1dcb0069 | 4d7563ef8a93dc34 + v_arg3 = 55858d05fdc8fe9c | 28060f57b206565f + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = fb257f353add24d0 + r_arg2 = d8291b32c56f5659 + r_arg3 = bd5c5d42ac4e1d08 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 06303c49e9402100 | 080c6ad2dfcdab12 + v_arg3 = 00a993fef2a24057 | 8361fbe362ea48ca + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 14e84eb64777c9ca + r_arg2 = bb7c04550a937a11 + r_arg3 = 8617058f5f53761e + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 344f1d8653c50768 | 01f71cfc7521089e + v_arg3 = e4ea5e722e0fafba | daf2fe1b860899b6 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = c3a89120891b95c8 + r_arg2 = 4c83fa6166e69e54 + r_arg3 = 5b090742b45abfa3 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 2cf0ab513884ad35 | 200ef7c8eb072369 + v_arg3 = 104f0399d8957015 | 20ac82d68ab427f0 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = cbea045b3faeb3a9 + r_arg2 = f370cd9a1fdc653e + r_arg3 = 0ad40abeb323d3b2 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 34cdc5e69ad3a5d9 | d0376e4fcbe684a3 + v_arg3 = d6ad4d2bbd69c115 | 4e13672943b1a564 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = f5c2d7890c812969 + r_arg2 = e1c482429e120ac9 + r_arg3 = e926a8224d5ddf01 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 19ab3f3d60fad661 | c529ad2741d1c8da + v_arg3 = 8e677a1b122cb586 | 22f9c426aaee5ddb + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = d09070cdb9158edf + r_arg2 = c80f175a31191a8c + r_arg3 = 927c350f17642aa8 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = ee21a3cb17ec3d3e | b8265325e24a62b7 + v_arg3 = 582e025d30aef611 | e03aa49d9f48edbc + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 70c42c09f7d8d285 + r_arg2 = a5ad3d61d02b3c7c + r_arg3 = a6e2785f0c01ced7 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = cc50f147b40cadf8 | 27be361b68015cc6 + v_arg3 = d7c051a057ac81fd | 1486cadea74d0bcd + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 309a1b9a1be5fa2f + r_arg2 = 778a1d12d6f2e9ad + r_arg3 = 8bb070ed4f2c7da3 + r_result = 0000000000000000 +insn vsceg: + v_arg1 = 0000000000000000 | 0000000000000000 + v_arg2 = 90ab5f6151e88ffb | 179223997194132d + v_arg3 = f6ac88126d946ef0 | 4e166e73aff642f1 + v_result = ffffffffffffffff | ffffffffffffffff + r_arg1 = 71ddc71de1c6e2d1 + r_arg2 = 05dd1429c4463510 + r_arg3 = 2e4c1152e7cc3db9 + r_result = 0000000000000000 diff --git a/none/tests/s390x/vector.vgtest b/none/tests/s390x/vector.vgtest new file mode 100644 index 0000000000..f72c1e710a --- /dev/null +++ b/none/tests/s390x/vector.vgtest @@ -0,0 +1,2 @@ +prog: vector +prereq: test -e vector && ../../../tests/s390x_features s390x-vx diff --git a/tests/s390x_features.c b/tests/s390x_features.c index 179b40ebfb..0da80b5d3c 100644 --- a/tests/s390x_features.c +++ b/tests/s390x_features.c @@ -39,25 +39,33 @@ jmp_buf env; #if defined(VGA_s390x) +/* Number of double words needed to store all facility bits. */ +#define S390_NUM_FACILITY_DW 3 + void handle_sigill(int signum) { longjmp(env, 1); } -unsigned long long stfle(void) +static void clear_facilities(unsigned long long *ret) { + unsigned int index; + for(index = 0; index < S390_NUM_FACILITY_DW; index++) + { + ret[index] = 0ULL; + } +} - unsigned long long ret; - +void stfle(unsigned long long *ret) +{ signal(SIGILL, handle_sigill); if (setjmp(env)) { /* stfle not available: assume no facilities */ - return 0; + clear_facilities(ret); } else { - asm volatile("lghi 0, 0\n" - ".insn s,0xb2b00000,%0\n" /* stfle */ - : "=Q" (ret)::"0", "cc"); - return ret; + register unsigned long long r0 asm("0") = S390_NUM_FACILITY_DW - 1; + asm volatile(".insn s,0xb2b00000,%0\n" /* stfle */ + : "=m" (*ret), "+d"(r0) :: "cc", "memory"); } } @@ -201,39 +209,42 @@ static model_info *get_host(void) static int go(char *feature, char *cpu) { - unsigned long long facilities; + unsigned long long facilities[S390_NUM_FACILITY_DW]; unsigned long long match; model_info *host, *from, *to, *p; char *colon; - facilities = stfle(); + clear_facilities(facilities); + stfle(facilities); if (strcmp(feature, "s390x-zarch") == 0 ) { - match = (facilities & FAC_BIT(1)) && (facilities & FAC_BIT(2)); + match = (facilities[0] & FAC_BIT(1)) && (facilities[0] & FAC_BIT(2)); } else if (strcmp(feature, "s390x-n3") == 0 ) { - match = facilities & FAC_BIT(0); + match = facilities[0] & FAC_BIT(0); } else if (strcmp(feature, "s390x-stfle") == 0 ) { - match = facilities & FAC_BIT(7); + match = facilities[0] & FAC_BIT(7); } else if (strcmp(feature, "s390x-ldisp") == 0 ) { - match = (facilities & FAC_BIT(18)) && (facilities & FAC_BIT(19)); + match = (facilities[0] & FAC_BIT(18)) && (facilities[0] & FAC_BIT(19)); } else if (strcmp(feature, "s390x-eimm") == 0 ) { - match = facilities & FAC_BIT(21); + match = facilities[0] & FAC_BIT(21); } else if (strcmp(feature, "s390x-stckf") == 0 ) { - match = facilities & FAC_BIT(25); + match = facilities[0] & FAC_BIT(25); } else if (strcmp(feature, "s390x-genins") == 0 ) { - match = facilities & FAC_BIT(34); + match = facilities[0] & FAC_BIT(34); } else if (strcmp(feature, "s390x-exrl") == 0 ) { - match = facilities & FAC_BIT(35); + match = facilities[0] & FAC_BIT(35); } else if (strcmp(feature, "s390x-etf3") == 0 ) { - match = facilities & FAC_BIT(30); + match = facilities[0] & FAC_BIT(30); } else if (strcmp(feature, "s390x-fpext") == 0 ) { - match = facilities & FAC_BIT(37); + match = facilities[0] & FAC_BIT(37); } else if (strcmp(feature, "s390x-dfp") == 0 ) { - match = facilities & FAC_BIT(42); + match = facilities[0] & FAC_BIT(42); } else if (strcmp(feature, "s390x-pfpo") == 0 ) { - match = facilities & FAC_BIT(44); + match = facilities[0] & FAC_BIT(44); } else if (strcmp(feature, "s390x-highw") == 0 ) { - match = facilities & FAC_BIT(45); + match = facilities[0] & FAC_BIT(45); + } else if (strcmp(feature, "s390x-vx") == 0 ) { + match = facilities[2] & FAC_BIT(0); } else { return 2; // Unrecognised feature. }