Lines Matching refs:mkexpr
263 static IRExpr* mkexpr ( IRTemp tmp )
1583 NULL, mkexpr(expTmp), NULL, newVal );
1587 mkexpr(oldTmp), mkexpr(expTmp) ),
1759 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dep1))) );
1760 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(dep2))) );
1785 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dep1))) );
1823 IRExpr_Mux0X( mkexpr(guard),
1827 IRExpr_Mux0X( mkexpr(guard),
1829 widenUto64(mkexpr(res)))) );
1831 IRExpr_Mux0X( mkexpr(guard),
1833 widenUto64(mkexpr(resUS)))) );
1857 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(res))) );
1884 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(arg1)) ));
1885 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(arg2)) ));
1982 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1985 binop(plus,mkexpr(ta1),mkexpr(ta2)),
1986 mkexpr(oldcn)) );
1993 storeLE( mkexpr(taddr), mkexpr(tres) );
1997 casLE( mkexpr(taddr),
1998 mkexpr(texpVal), mkexpr(tres), restart_point );
2003 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(ta1)) ));
2004 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(binop(xor, mkexpr(ta2),
2005 mkexpr(oldcn)) )) );
2006 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
2041 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
2044 binop(minus,mkexpr(ta1),mkexpr(ta2)),
2045 mkexpr(oldcn)) );
2052 storeLE( mkexpr(taddr), mkexpr(tres) );
2056 casLE( mkexpr(taddr),
2057 mkexpr(texpVal), mkexpr(tres), restart_point );
2062 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(ta1) )) );
2063 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(binop(xor, mkexpr(ta2),
2064 mkexpr(oldcn)) )) );
2065 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
2202 stmt( IRStmt_Put( OFFB_RIP, mkexpr(t) ) );
2256 binop(Iop_Sub64, mkexpr(new_rsp), mkU64(szB)),
2258 mkexpr(nia)
2362 //.. mkIRExprVec_4( mkexpr(ldt_ptr), mkexpr(gdt_ptr),
2363 //.. mkexpr(seg_selector), virtual)
2373 //.. binop(Iop_CmpNE32, unop(Iop_64HIto32, mkexpr(r64)), mkU32(0)),
2380 //.. return unop(Iop_64to32, mkexpr(r64));
2831 putIRegG(size, pfx, rm, mkexpr(dst1));
2836 putIRegG(size, pfx, rm, mkexpr(dst1));
2838 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2844 putIRegG(size, pfx, rm, mkexpr(dst1));
2855 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
2860 putIRegG(size, pfx, rm, mkexpr(dst1));
2865 putIRegG(size, pfx, rm, mkexpr(dst1));
2867 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2873 putIRegG(size, pfx, rm, mkexpr(dst1));
2945 putIRegE(size, pfx, rm, mkexpr(dst1));
2950 putIRegE(size, pfx, rm, mkexpr(dst1));
2952 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2958 putIRegE(size, pfx, rm, mkexpr(dst1));
2970 assign(dst0, loadLE(ty,mkexpr(addr)));
2995 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2999 casLE( mkexpr(addr),
3000 mkexpr(dst0)/*expval*/,
3001 mkexpr(dst1)/*newval*/, guest_RIP_curr_instr );
3004 storeLE(mkexpr(addr), mkexpr(dst1));
3057 putIRegG(size, pfx, rm, loadLE(szToITy(size), mkexpr(addr)));
3103 storeLE( mkexpr(addr), getIRegG(size, pfx, rm) );
3131 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3137 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3154 putIRegRAX(size, mkexpr(dst1));
3190 loadLE(szToITy(szs),mkexpr(addr))));
3215 assign( dst128, binop(op, mkexpr(src128), mkexpr(t)) );
3216 putIReg64( R_RAX, unop(Iop_128to64,mkexpr(dst128)) );
3217 putIReg64( R_RDX, unop(Iop_128HIto64,mkexpr(dst128)) );
3228 binop(op, mkexpr(src64), mkexpr(t)) );
3229 putIRegRAX( 4, unop(Iop_64to32,mkexpr(dst64)) );
3230 putIRegRDX( 4, unop(Iop_64HIto32,mkexpr(dst64)) );
3239 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
3240 putIRegRAX( 2, unop(Iop_32to16,unop(Iop_64to32,mkexpr(dst64))) );
3241 putIRegRDX( 2, unop(Iop_32to16,unop(Iop_64HIto32,mkexpr(dst64))) );
3251 binop(op, mkexpr(src64),
3252 unop(widen1632, unop(widen816, mkexpr(t)))) );
3255 unop(Iop_64to32,mkexpr(dst64)))) );
3258 unop(Iop_64HIto32,mkexpr(dst64)))) );
3307 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3315 putIRegE(sz, pfx, modrm, mkexpr(dst1));
3324 assign(dst0, loadLE(ty,mkexpr(addr)));
3349 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3352 casLE( mkexpr(addr), mkexpr(dst0)/*expVal*/,
3353 mkexpr(dst1)/*newVal*/,
3356 storeLE(mkexpr(addr), mkexpr(dst1));
3403 assign(dst0, loadLE(ty,mkexpr(addr)));
3441 = mkIRExprVec_4( widenUto64(mkexpr(dst0)), /* thing to rotate */
3443 mkexpr(old_rflags),
3456 = mkIRExprVec_4( widenUto64(mkexpr(dst0)), /* thing to rotate */
3458 mkexpr(old_rflags),
3470 assign( dst1, narrowTo(ty, mkexpr(new_value)) );
3472 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(new_rflags) ));
3513 assign( pre64, op64==Iop_Sar64 ? widenSto64(mkexpr(dst0))
3514 : widenUto64(mkexpr(dst0)) );
3517 assign( res64, binop(op64, mkexpr(pre64), mkexpr(shift_amt)) );
3522 mkexpr(pre64),
3525 mkexpr(shift_amt), mkU8(1)),
3532 assign( dst1, narrowTo(ty, mkexpr(res64)) );
3553 assign(rot_amt, mkexpr(rot_amt64));
3555 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt64), mkU8(8*sz-1)));
3563 mkexpr(dst0),
3564 mkexpr(rot_amt)
3567 mkexpr(dst0),
3568 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
3580 mkexpr(dst0),
3581 mkexpr(rot_amt)
3584 mkexpr(dst0),
3585 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
3601 IRExpr_Mux0X( mkexpr(rot_amt64),
3605 IRExpr_Mux0X( mkexpr(rot_amt64),
3607 widenUto64(mkexpr(dst1)))) );
3609 IRExpr_Mux0X( mkexpr(rot_amt64),
3613 IRExpr_Mux0X( mkexpr(rot_amt64),
3615 mkexpr(oldFlags))) );
3620 putIRegE(sz, pfx, modrm, mkexpr(dst1));
3631 storeLE(mkexpr(addr), mkexpr(dst1));
3703 assign( t2, widenUto64(loadLE(ty, mkexpr(t_addr))) );
3714 assign( t2m, binop(Iop_Or64, mkU64(mask), mkexpr(t2)) );
3717 assign( t2m, binop(Iop_And64, mkU64(mask), mkexpr(t2)) );
3720 assign( t2m, binop(Iop_Xor64, mkU64(mask), mkexpr(t2)) );
3730 putIRegE(sz, pfx, modrm, narrowTo(ty, mkexpr(t2m)));
3733 casLE( mkexpr(t_addr),
3734 narrowTo(ty, mkexpr(t2))/*expd*/,
3735 narrowTo(ty, mkexpr(t2m))/*new*/,
3738 storeLE(mkexpr(t_addr), narrowTo(ty, mkexpr(t2m)));
3750 binop(Iop_Shr64, mkexpr(t2), mkU8(src_val)),
3781 assign( res128, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3782 assign( resHi, unop(Iop_128HIto64,mkexpr(res128)));
3783 assign( resLo, unop(Iop_128to64,mkexpr(res128)));
3784 putIReg64(R_RDX, mkexpr(resHi));
3785 putIReg64(R_RAX, mkexpr(resLo));
3795 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3796 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
3797 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
3798 putIRegRDX(4, mkexpr(resHi));
3799 putIRegRAX(4, mkexpr(resLo));
3809 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3810 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
3811 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
3812 putIRegRDX(2, mkexpr(resHi));
3813 putIRegRAX(2, mkexpr(resLo));
3823 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3824 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
3825 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
3826 putIRegRAX(2, mkexpr(res16));
3886 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
3887 mkexpr(src)));
3889 putIRegE(sz, pfx, modrm, mkexpr(dst1));
3934 assign(t1, loadLE(ty,mkexpr(addr)));
3941 mkexpr(t1),
3952 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
3954 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
3957 storeLE( mkexpr(addr), mkexpr(dst1) );
3966 assign(src, mkexpr(t1));
3967 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
3968 mkexpr(src)));
3970 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
3973 storeLE( mkexpr(addr), mkexpr(dst1) );
4020 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4021 putIRegE(1, pfx, modrm, mkexpr(t2));
4025 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4026 putIRegE(1, pfx, modrm, mkexpr(t2));
4038 assign( t1, loadLE(ty, mkexpr(addr)) );
4041 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4043 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
4046 storeLE( mkexpr(addr), mkexpr(t2) );
4051 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4053 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
4056 storeLE( mkexpr(addr), mkexpr(t2) );
4096 mkexpr(t1), mkU(ty,1)));
4098 putIRegE(sz,pfx,modrm, mkexpr(t2));
4103 mkexpr(t1), mkU(ty,1)));
4105 putIRegE(sz,pfx,modrm, mkexpr(t2));
4115 putIReg64(R_RSP, mkexpr(t2));
4116 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta+1));
4144 assign(t1, loadLE(ty,mkexpr(addr)));
4150 mkexpr(t1), mkU(ty,1)));
4152 casLE( mkexpr(addr),
4153 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
4155 storeLE(mkexpr(addr),mkexpr(t2));
4162 mkexpr(t1), mkU(ty,1)));
4164 casLE( mkexpr(addr),
4165 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
4167 storeLE(mkexpr(addr),mkexpr(t2));
4176 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4179 putIReg64(R_RSP, mkexpr(t2));
4180 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta+len));
4191 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4202 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4205 putIReg64(R_RSP, mkexpr(t2) );
4206 storeLE( mkexpr(t2), mkexpr(t3) );
4276 storeLE( mkexpr(td), loadLE(ty,mkexpr(ts)) );
4278 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4279 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4300 putIRegRAX ( sz, loadLE(ty, mkexpr(ts)) );
4302 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4323 storeLE( mkexpr(td), mkexpr(ta) );
4325 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4349 assign( tdv, loadLE(ty,mkexpr(td)) );
4351 assign( tsv, loadLE(ty,mkexpr(ts)) );
4355 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4356 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4381 assign( tdv, loadLE(ty,mkexpr(td)) );
4385 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4413 cmp = binop(Iop_CmpEQ32, mkexpr(tc), mkU32(0));
4417 cmp = binop(Iop_CmpEQ64, mkexpr(tc), mkU64(0));
4424 putIReg32(R_RCX, binop(Iop_Sub32, mkexpr(tc), mkU32(1)) );
4426 putIReg64(R_RCX, binop(Iop_Sub64, mkexpr(tc), mkU64(1)) );
4470 assign( te, loadLE(ty,mkexpr(addr)) );
4475 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
4477 putIRegG(size, pfx, rm, mkexpr(resLo) );
4518 assign(te, loadLE(ty, mkexpr(addr)));
4527 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
4531 putIRegG(size, pfx, rm, mkexpr(resLo));
4565 mkexpr(old),
4566 mkexpr(mask[i])),
4568 binop(Iop_Shr16, mkexpr(old), mkU8(shift[i])),
4569 mkexpr(mask[i]))));
4593 mkexpr(old),
4594 mkexpr(mask[i])),
4596 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
4597 mkexpr(mask[i]))));
4622 mkexpr(old),
4623 mkexpr(mask[i])),
4625 binop(Iop_Shr64, mkexpr(old), mkU8(shift[i])),
4626 mkexpr(mask[i]))));
4646 assign(src64, widenUto64( mkexpr(src) ));
4650 binop(Iop_Shl64, mkexpr(src64),
4659 binop(Iop_CmpEQ64, mkexpr(src64x), mkU64(0))),
4660 unop(Iop_Clz64, mkexpr(src64x)),
4665 assign(res, narrowTo(ty, mkexpr(res64)));
4892 loadLE(Ity_F64,mkexpr(addr))
4899 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr)))
4917 loadLE(Ity_F64,mkexpr(addr)),
4924 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr))),
5005 binop(Iop_Add32, mkexpr(t32), mkU32(32768))),
5008 unop(Iop_32to16, mkexpr
5058 loadLE(Ity_F32,mkexpr(addr)))),
5076 loadLE(Ity_F32,mkexpr(addr)))),
5185 loadLE(Ity_F32, mkexpr(addr))));
5190 storeLE(mkexpr(addr),
5196 storeLE(mkexpr(addr),
5210 mkIRExprVec_1( mkexpr(addr) )
5216 d->mAddr = mkexpr(addr);
5245 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
5246 put_emwarn( mkexpr(ew) );
5249 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
5279 loadLE(Ity_I16, mkexpr(addr)))
5284 put_fpround( unop(Iop_64to32, mkexpr(t64)) );
5285 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
5286 put_emwarn( mkexpr(ew) );
5292 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
5308 mkIRExprVec_1( mkexpr(addr) )
5313 d->mAddr = mkexpr(addr);
5349 mkexpr(addr),
5376 put_ST(0, mkexpr(t1));
5386 put_ST_UNCHECKED(0, mkexpr(t2));
5387 put_ST_UNCHECKED(r_src, mkexpr(t1));
5517 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
5523 mkIRExprVec_2( mkexpr(argI),
5531 mkIRExprVec_2( mkexpr(argI),
5534 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
5535 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
5537 put_ST_UNCHECKED(0, mkexpr(expF) );
5540 put_ST(0, mkexpr(sigF) );
5555 mkexpr(a1),
5556 mkexpr(a2)));
5561 mkexpr(a1),
5562 mkexpr(a2)) ));
5582 mkexpr(a1),
5583 mkexpr(a2)));
5588 mkexpr(a1),
5589 mkexpr(a2)) ));
5618 mkexpr(a1)));
5623 mkexpr(a1)));
5716 loadLE(Ity_I32, mkexpr(addr)))));
5724 loadLE(Ity_I32, mkexpr(addr))),
5817 loadLE(Ity_I32, mkexpr(addr))));
5822 storeLE( mkexpr(addr),
5829 storeLE( mkexpr(addr),
5835 storeLE( mkexpr(addr),
5846 IRExpr** args = mkIRExprVec_1 ( mkexpr(addr) );
5857 d->mAddr = mkexpr(addr);
5863 put_ST(0, unop(Iop_ReinterpI64asF64, mkexpr(val)));
5874 = mkIRExprVec_2( mkexpr(addr),
5885 d->mAddr = mkexpr(addr);
6046 //.. loadLE(Ity_F64,mkexpr(addr))),
6061 loadLE(Ity_F64,mkexpr(addr))),
6142 put_ST(0, loadLE(Ity_F64, mkexpr(addr)));
6147 storeLE( mkexpr(addr),
6154 storeLE(mkexpr(addr), get_ST(0));
6159 storeLE(mkexpr(addr), get_ST(0));
6175 mkIRExprVec_1( mkexpr(addr) )
6186 mkIRExprVec_1( mkexpr(addr) )
6195 d->mAddr = mkexpr(addr);
6228 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
6229 put_emwarn( mkexpr(ew) );
6232 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
6256 mkIRExprVec_1( mkexpr(addr) )
6266 mkIRExprVec_1( mkexpr(addr) )
6273 d->mAddr = mkexpr(addr);
6313 storeLE( mkexpr(addr), sw );
6438 loadLE(Ity_I16, mkexpr(addr))))));
6447 loadLE(Ity_I16, mkexpr(addr)))),
6526 loadLE(Ity_I16, mkexpr(addr)))));
6531 storeLE( mkexpr(addr),
6539 storeLE( mkexpr(addr),
6546 storeLE( mkexpr(addr),
6557 loadLE(Ity_I64, mkexpr(addr))));
6562 storeLE( mkexpr(addr),
6801 argE = loadLE(Ity_I64, mkexpr(addr));
6828 putMMXReg( gregLO3ofRM(modrm), mkexpr(res) );
6864 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
6871 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
6891 unop(Iop_1Uto8,binop(Iop_CmpLT64U,mkexpr(amt),mkU64(size))),
6893 binop(op, mkexpr(g0), mkexpr(amt8))
6901 unop(Iop_1Uto8,binop(Iop_CmpLT64U,mkexpr(amt),mkU64(size))),
6902 binop(op, mkexpr(g0), mkU8(size-1)),
6903 binop(op, mkexpr(g0), mkexpr(amt8))
6910 putMMXReg( gregLO3ofRM(rm), mkexpr(g1) );
6954 : binop(op, mkexpr(e0), mkU8(amt))
6959 ? binop(op, mkexpr(e0), mkU8(size-1))
6960 : binop(op, mkexpr(e0), mkU8(amt))
6966 putMMXReg( eregLO3ofRM(rm), mkexpr(e1) );
7009 loadLE(Ity_I32, mkexpr(addr)) ) );
7028 loadLE(Ity_I64, mkexpr(addr)) );
7051 storeLE( mkexpr(addr),
7070 storeLE( mkexpr(addr),
7094 putMMXReg( gregLO3ofRM(modrm), loadLE(Ity_I64, mkexpr(addr)) );
7115 storeLE( mkexpr(addr), getMMXReg(gregLO3ofRM(modrm)) );
7334 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
7335 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
7339 mkexpr(regD),
7340 mkexpr(mask) ),
7342 mkexpr(olddata),
7343 unop(Iop_Not64, mkexpr(mask)))) );
7344 storeLE( mkexpr(addr), mkexpr(newdata) );
7378 mkexpr(amt),
7379 mkexpr(base),
7381 binop(Iop_Shl64, mkexpr(base), mkexpr(amt)),
7382 binop(Iop_Shr64, mkexpr(xtra),
7383 binop(Iop_Sub8, mkU8(64), mkexpr(amt)))
7399 mkexpr(amt),
7400 mkexpr(base),
7402 binop(Iop_Shr64, mkexpr(base), mkexpr(amt)),
7403 binop(Iop_Shl64, mkexpr(xtra),
7404 binop(Iop_Sub8, mkU8(64), mkexpr(amt)))
7469 assign( esrc, loadLE(ty, mkexpr(addr)) );
7482 binop(Iop_Sub8, mkexpr(tmpSH), mkU8(1) ),
7494 assign( tmp64, binop(Iop_32HLto64, mkexpr(esrc), mkexpr(gsrc)) );
7497 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSH)),
7501 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSS)),
7506 assign( tmp64, binop(Iop_32HLto64, mkexpr(gsrc), mkexpr(esrc)) );
7507 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7508 assign( rss64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSS)) );
7514 binop(Iop_16HLto32, mkexpr(esrc), mkexpr(gsrc)),
7515 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(gsrc))
7520 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSH)),
7526 binop(Iop_Shl64, unop(Iop_16Uto64, mkexpr(esrc)),
7528 mkexpr(tmpSS)),
7535 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(gsrc)),
7536 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(esrc))
7539 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7542 unop(Iop_16Uto64, mkexpr(esrc)),
7543 mkexpr(tmpSS)) );
7561 assign( resTy, narrowTo(ty, mkexpr(res64)) );
7562 assign( rssTy, narrowTo(ty, mkexpr(rss64)) );
7569 putIRegE(sz, pfx, modrm, mkexpr(resTy));
7571 storeLE( mkexpr(addr), mkexpr(resTy) );
7643 putIReg64(R_RSP, mkexpr(t_rsp));
7645 storeLE( mkexpr(t_rsp), getIRegE(sz, pfx, modrm) );
7648 assign( t_addr0, mkexpr(t_rsp) );
7653 mkexpr(t_bitno0),
7659 assign( t_bitno1, mkexpr(t_bitno0) );
7670 mkexpr(t_addr0),
7671 binop(Iop_Sar64, mkexpr(t_bitno1), mkU8(3))) );
7677 binop(Iop_And64, mkexpr(t_bitno1), mkU64(7))) );
7683 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
7688 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
7694 binop(Iop_Or8, mkexpr(t_fetched), mkexpr(t_mask)) );
7698 binop(Iop_Xor8, mkexpr(t_fetched), mkexpr(t_mask)) );
7702 binop(Iop_And8, mkexpr(t_fetched),
7703 unop(Iop_Not8, mkexpr(t_mask))) );
7709 casLE( mkexpr(t_addr1), mkexpr(t_fetched)/*expd*/,
7710 mkexpr(t_new)/*new*/,
7713 storeLE( mkexpr(t_addr1), mkexpr(t_new) );
7725 unop(Iop_8Uto64, mkexpr(t_fetched)),
7726 mkexpr(t_bitno2)),
7740 putIRegE(sz, pfx, modrm, loadLE(szToITy(sz), mkexpr(t_rsp)) );
7741 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t_rsp), mkU64(288)) );
7780 assign( src, loadLE(ty, mkexpr(addr)) );
7789 assign( src64, widenUto64(mkexpr(src)) );
7796 mkexpr(src64), mkU64(0))) );
7804 IRExpr_Mux0X( mkexpr(src8),
7844 mkexpr(src8),
7848 fwds ? unop(Iop_Ctz64, mkexpr(src64))
7851 unop(Iop_Clz64, mkexpr(src64)))
7856 assign( dst, unop(Iop_64to16, mkexpr(dst64)) );
7859 assign( dst, unop(Iop_64to32, mkexpr(dst64)) );
7861 assign( dst, mkexpr(dst64) );
7864 putIRegG( sz, pfx, modrm, mkexpr(dst) );
7882 putIReg64( R_RAX, mkexpr(t2) );
7883 putIRegRexB(8, pfx, regLo3, mkexpr(t1) );
7887 putIReg32( R_RAX, mkexpr(t2) );
7888 putIRegRexB(4, pfx, regLo3, mkexpr(t1) );
7892 putIReg16( R_RAX, mkexpr(t2) );
7893 putIRegRexB(2, pfx, regLo3, mkexpr(t1) );
7919 binop(Iop_And64, mkexpr(oldflags), mkU64(AMD64G_CC_MASK_O)),
7944 = binop(Iop_Or64, binop(Iop_And64, mkexpr(flags), mkU64(mask_SZACP)),
7992 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
7993 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
7994 putIRegRAX(size, mkexpr(acc2));
7995 putIRegE(size, pfx, rm, mkexpr(dest2));
8003 assign( dest, loadLE(ty, mkexpr(addr)) );
8009 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
8010 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
8011 putIRegRAX(size, mkexpr(acc2));
8012 storeLE( mkexpr(addr), mkexpr(dest2) );
8027 mkIRCAS( IRTemp_INVALID, dest, Iend_LE, mkexpr(addr),
8028 NULL, mkexpr(acc), NULL, mkexpr(src) )
8032 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
8033 putIRegRAX(size, mkexpr(acc2));
8083 mkexpr(tmpd),
8084 mkexpr(tmps) )
8095 assign( tmps, loadLE(ty, mkexpr(addr)) );
8101 mkexpr(tmpd),
8102 mkexpr(tmps) )
8143 mkexpr(tmpd), mkexpr(tmpt0)) );
8145 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8146 putIRegE(sz, pfx, rm, mkexpr(tmpt1));
8156 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8159 mkexpr(tmpd), mkexpr(tmpt0)) );
8161 storeLE( mkexpr(addr), mkexpr(tmpt1) );
8162 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8171 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8174 mkexpr(tmpd), mkexpr(tmpt0)) );
8175 casLE( mkexpr(addr), mkexpr(tmpd)/*expVal*/,
8176 mkexpr(tmpt1)/*newVal*/, guest_RIP_curr_instr );
8178 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8204 //.. putSReg( gregOfRM(rm), loadLE(Ity_I16, mkexpr(addr)) );
8235 //.. storeLE( mkexpr(addr), getSReg(gregOfRM(rm)) );
8251 //.. putIReg(4, R_ESP, mkexpr(ta));
8252 //.. storeLE( mkexpr(ta), mkexpr(t1) );
8265 //.. assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
8267 //.. putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(ta), mkU32(sz)) );
8268 //.. putSReg( sreg, mkexpr(t1) );
8279 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
8280 assign(t3, binop(Iop_Add64, mkexpr(t1), mkU64(8+d64)));
8281 putIReg64(R_RSP, mkexpr(t3));
8322 mkexpr(addr))) );
8377 loadLE(Ity_I32, mkexpr(addr))) );
8379 binop(op, gpart, mkexpr(epart)) );
8413 loadLE(Ity_I64, mkexpr(addr))) );
8415 binop(op, gpart, mkexpr(epart)) );
8446 unop(op, loadLE(Ity_V128, mkexpr(addr))) );
8477 mkexpr(oldG0),
8479 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
8488 mkexpr(oldG0),
8489 loadLE(Ity_I32, mkexpr(addr)) ));
8490 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
8521 mkexpr(oldG0),
8523 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
8532 mkexpr(oldG0),
8533 loadLE(Ity_I64, mkexpr(addr)) ));
8534 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
8568 epart = loadLE(Ity_V128, mkexpr(addr));
8744 ? loadLE(Ity_V128, mkexpr(addr))
8746 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
8748 unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr)))
8760 unop(Iop_NotV128, mkexpr(plain)) );
8766 binop(Iop_XorV128, mkexpr(plain), mkV128(mask)) );
8769 putXMMReg( gregOfRexRM(pfx,rm), mkexpr(plain) );
8800 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
8807 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
8828 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size))),
8830 binop(op, mkexpr(g0), mkexpr(amt8))
8839 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size))),
8840 binop(op, mkexpr(g0), mkU8(size-1)),
8841 binop(op, mkexpr(g0), mkexpr(amt8))
8848 putXMMReg( gregOfRexRM(pfx,rm), mkexpr(g1) );
8891 : binop(op, mkexpr(e0), mkU8(amt))
8896 ? binop(op, mkexpr(e0), mkU8(size-1))
8897 : binop(op, mkexpr(e0), mkU8(amt))
8903 putXMMReg( eregOfRexRM(pfx,rm), mkexpr(e1) );
8935 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
8936 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
8947 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
8948 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
8949 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
8950 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
8960 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
8961 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
8974 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
8975 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
8986 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
8987 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
8988 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
8989 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
8999 binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)),
9000 binop(Iop_16HLto32, mkexpr(t1), mkexpr(t0))
9019 assign( *t0, unop(Iop_V256to64_0, mkexpr(t256)) );
9020 assign( *t1, unop(Iop_V256to64_1, mkexpr(t256)) );
9021 assign( *t2, unop(Iop_V256to64_2, mkexpr(t256)) );
9022 assign( *t3, unop(Iop_V256to64_3, mkexpr(t256)) );
9035 assign(*t1, unop(Iop_V256toV128_1, mkexpr(t256)));
9036 assign(*t0, unop(Iop_V256toV128_0, mkexpr(t256)));
9065 assign( *t0, unop(Iop_V128to64, mkexpr(t128)) );
9066 assign( *t1, unop(Iop_V128HIto64, mkexpr(t128)) );
9079 binop(Iop_32HLto64, mkexpr(t7), mkexpr(t6)),
9080 binop(Iop_32HLto64, mkexpr(t5), mkexpr(t4)) ),
9082 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
9083 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0)) )
9094 binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)),
9095 binop(Iop_64HLtoV128, mkexpr(t1), mkexpr(t0))
9119 binop(Iop_InterleaveHI16x4, mkexpr(aa), mkexpr(aa)),
9123 binop(Iop_InterleaveLO16x4, mkexpr(aa), mkexpr(aa)),
9127 binop(Iop_InterleaveHI16x4, mkexpr(bb), mkexpr(bb)),
9131 binop(Iop_InterleaveLO16x4, mkexpr(bb), mkexpr(bb)),
9142 binop(Iop_Mul32x2, mkexpr(aahi32s), mkexpr(bbhi32s)),
9145 mkexpr(one32x2)
9158 binop(Iop_Mul32x2, mkexpr(aalo32s), mkexpr(bblo32s)),
9161 mkexpr(one32x2)
9167 binop(Iop_CatEvenLanes16x4, mkexpr(rHi), mkexpr(rLo));
9198 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
9199 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
9200 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
9204 binop(Iop_And64, mkexpr(bb), mkexpr(posMask)),
9205 binop(Iop_And64, mkexpr(bbNeg), mkexpr(negMask)) );
9236 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
9237 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
9239 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
9242 binop(Iop_And64, mkexpr(aa), mkexpr(posMask)),
9243 binop(Iop_And64, mkexpr(aaNeg), mkexpr(negMask)) ));
9253 assign(aaHi, unop(Iop_V128HIto64, mkexpr(aa)));
9254 assign(aaLo, unop(Iop_V128to64, mkexpr(aa)));
9256 mkexpr(math_PABS_MMX(aaHi, laneszB)),
9257 mkexpr(math_PABS_MMX(aaLo, laneszB))));
9281 binop(Iop_Shl64, mkexpr(hi64), mkU8(8*(8-byteShift))),
9282 binop(Iop_Shr64, mkexpr(lo64), mkU8(8*byteShift))
9296 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
9297 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
9298 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
9299 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
9302 assign( rHi, mkexpr(sHi) );
9303 assign( rLo, mkexpr(sLo) );
9310 assign( rHi, mkexpr(dLo) );
9311 assign( rLo, mkexpr(sHi) );
9318 assign( rHi, mkexpr(dHi) );
9319 assign( rLo, mkexpr(dLo) );
9322 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-16))) );
9327 assign( rLo, mkexpr(dHi) );
9331 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-24))) );
9340 assign( res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
9355 binop(Iop_And64,mkexpr(effective_addr),mkU64(mask)),
9528 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
9544 binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)) ),
9571 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
9588 unop(Iop_F32toF64,mkexpr(argL)),
9589 unop(Iop_F32toF64,mkexpr(argR)))),
9616 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9637 (gregOfRexRM(pfx,modrm), mkexpr(dV));
9656 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
9657 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
9660 assign( lo64r, mkexpr(lo64) );
9661 assign( hi64r, mkexpr(hi64) );
9666 assign( lo64r, mkexpr(hi64) );
9671 assign( lo64r, binop( Iop_Shr64, mkexpr(hi64), mkU8( 8*(imm-8) ) ));
9673 assign( hi64r, binop( Iop_Shr64, mkexpr(hi64), mkU8(8 * imm) ));
9676 binop(Iop_Shr64, mkexpr(lo64),
9678 binop(Iop_Shl64, mkexpr(hi64),
9684 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
9703 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
9704 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
9707 assign( lo64r, mkexpr(lo64) );
9708 assign( hi64r, mkexpr(hi64) );
9713 assign( hi64r, mkexpr(lo64) );
9718 assign( hi64r, binop( Iop_Shl64, mkexpr(lo64), mkU8( 8*(imm-8) ) ));
9720 assign( lo64r, binop( Iop_Shl64, mkexpr(lo64), mkU8(8 * imm) ));
9723 binop(Iop_Shl64, mkexpr(hi64),
9725 binop(Iop_Shr64, mkexpr(lo64),
9731 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
9757 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9773 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo)) );
9777 binop( Iop_F64toI64S, mkexpr(rmode), mkexpr(f64lo)) );
9805 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
9822 mkexpr(rmode),
9823 unop(Iop_F32toF64, mkexpr(f32lo))) );
9828 mkexpr(rmode),
9829 unop(Iop_F32toF64, mkexpr(f32lo))) );
9855 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
9857 binop(Iop_Add64,mkexpr(addr),mkU64(4))) );
9863 putXMMRegLane64F( rG, 1, unop(Iop_F32toF64, mkexpr(f32hi)) );
9864 putXMMRegLane64F( rG, 0, unop(Iop_F32toF64, mkexpr(f32lo)) );
9893 assign( f32_0, loadLE(Ity_F32, mkexpr(addr)) );
9895 binop(Iop_Add64,mkexpr(addr),mkU64(4))) );
9897 binop(Iop_Add64,mkexpr(addr),mkU64(8))) );
9899 binop(Iop_Add64,mkexpr(addr),mkU64(12))) );
9904 putYMMRegLane64F( rG, 3, unop(Iop_F32toF64, mkexpr(f32_3)) );
9905 putYMMRegLane64F( rG, 2, unop(Iop_F32toF64, mkexpr(f32_2)) );
9906 putYMMRegLane64F( rG, 1, unop(Iop_F32toF64, mkexpr(f32_1)) );
9907 putYMMRegLane64F( rG, 0, unop(Iop_F32toF64, mkexpr(f32_0)) );
9930 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9940 unop(Iop_V128to64, mkexpr(argV))) );
9942 unop(Iop_V128HIto64, mkexpr(argV))) );
9944 # define CVT(_t) binop( Iop_F64toF32, mkexpr(rmode), mkexpr(_t) )
9977 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9991 mkexpr(rmode), \
9993 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10027 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10041 mkexpr(rmode), \
10043 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10079 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10094 unop(Iop_V128to64, mkexpr(argV))) );
10096 unop(Iop_V128HIto64, mkexpr(argV))) );
10099 mkexpr(rmode), \
10100 mkexpr(_t) )
10134 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10153 mkexpr(rmode), \
10155 mkexpr(_t) ) )
10188 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10202 mkexpr(rmode), \
10203 unop(Iop_I32StoF64,mkexpr(_t)))
10235 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10252 mkexpr(rmode), \
10253 unop(Iop_I32StoF64,mkexpr(_t)))
10285 mkIRExprVec_2( mkexpr(t1), mkexpr(t0) )));
10286 putIReg32(rG, unop(Iop_64to32,mkexpr(t5)));
10318 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10319 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10320 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10321 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10323 assign(res, xIsH ? binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1))
10324 : binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)));
10341 ? IRExpr_Qop(Iop_64x4toV256, mkexpr(s3), mkexpr(d3),
10342 mkexpr(s1), mkexpr(d1))
10343 : IRExpr_Qop(Iop_64x4toV256, mkexpr(s2), mkexpr(d2),
10344 mkexpr(s0), mkexpr(d0)));
10364 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10402 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10414 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10415 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10416 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10417 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10419 # define SELD(n) mkexpr((n)==0 ? d0 : d1)
10420 # define SELS(n) mkexpr((n)==0 ? s0 : s1)
10441 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10462 binop( Iop_AndV128, mkexpr(sV),
10463 mkexpr(imm8_mask) ),
10464 binop( Iop_AndV128, mkexpr(dV),
10465 unop( Iop_NotV128, mkexpr(imm8_mask) ) ) ) );
10479 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10495 binop( Iop_AndV128, mkexpr(sV),
10496 mkexpr(imm8_mask) ),
10497 binop( Iop_AndV128, mkexpr(dV),
10498 unop( Iop_NotV128, mkexpr(imm8_mask) ) ) ) );
10512 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10532 binop( Iop_AndV128, mkexpr(sV),
10533 mkexpr(imm16_mask) ),
10534 binop( Iop_AndV128, mkexpr(dV),
10535 unop( Iop_NotV128, mkexpr(imm16_mask) ) ) ) );
10550 binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)),
10551 binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) ));
10566 binop( Iop_MullS32, mkexpr(d2), mkexpr(s2)),
10567 binop( Iop_MullS32, mkexpr(d0), mkexpr(s0)) ));
10583 mkIRExprVec_2( mkexpr(sVhi), mkexpr(dVhi))));
10587 mkIRExprVec_2( mkexpr(sVlo), mkexpr(dVlo))));
10589 assign( res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo))) ;
10601 assign( addV, binop(Iop_Add64Fx2, mkexpr(dV), mkexpr(sV)) );
10602 assign( subV, binop(Iop_Sub64Fx2, mkexpr(dV), mkexpr(sV)) );
10604 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
10605 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
10608 assign( res, binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
10620 assign( addV, binop(Iop_Add64Fx4, mkexpr(dV), mkexpr(sV)) );
10621 assign( subV, binop(Iop_Sub64Fx4, mkexpr(dV), mkexpr(sV)) );
10639 assign( addV, binop(Iop_Add32Fx4, mkexpr(dV), mkexpr(sV)) );
10640 assign( subV, binop(Iop_Sub32Fx4, mkexpr(dV), mkexpr(sV)) );
10660 assign( addV, binop(Iop_Add32Fx8, mkexpr(dV), mkexpr(sV)) );
10661 assign( subV, binop(Iop_Sub32Fx8, mkexpr(dV), mkexpr(sV)) );
10699 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10709 assign( sVmut, unop(xIsH ? Iop_V128HIto64 : Iop_V128to64, mkexpr(sV)) );
10710 assign( sVcon, unop(xIsH ? Iop_V128to64 : Iop_V128HIto64, mkexpr(sV)) );
10719 assign(dV, xIsH ? binop(Iop_64HLtoV128, mkexpr(dVmut), mkexpr(sVcon))
10720 : binop(Iop_64HLtoV128, mkexpr(sVcon), mkexpr(dVmut)) );
10722 (isAvx ? putYMMRegLoAndZU : putXMMReg)(rG, mkexpr(dV));
10751 case 0: assign(d16, unop(Iop_32to16, mkexpr(s0))); break;
10752 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(s0))); break;
10753 case 2: assign(d16, unop(Iop_32to16, mkexpr(s1))); break;
10754 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(s1))); break;
10755 case 4: assign(d16, unop(Iop_32to16, mkexpr(s2))); break;
10756 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(s2))); break;
10757 case 6: assign(d16, unop(Iop_32to16, mkexpr(s3))); break;
10758 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(s3))); break;
10761 putIReg32(rG, unop(Iop_16Uto32, mkexpr(d16)));
10783 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
10789 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)))
10793 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)))
10820 mkexpr(addr),
10864 loadLE(Ity_I32, mkexpr(addr))
10870 put_sse_roundingmode( unop(Iop_64to32, mkexpr(t64)) );
10871 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
10872 put_emwarn( mkexpr(ew) );
10878 binop(Iop_CmpNE64, unop(Iop_32Uto64,mkexpr(ew)), mkU64(0)),
10897 unop(Iop_16Uto64, mkexpr(u16)),
10900 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
10902 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
10908 mkexpr(tmp128),
10909 binop(Iop_AndV128, mkexpr(v128), mkV128(mask))) );
10928 mkIRExprVec_2( mkexpr(s1), mkexpr(d1))),
10932 mkIRExprVec_2( mkexpr(s0), mkexpr(d0)))) );
10963 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
10966 mkexpr(regD),
10967 mkexpr(mask) ),
10969 mkexpr(olddata),
10970 unop(Iop_NotV128, mkexpr(mask)))) );
10971 storeLE( mkexpr(addr), mkexpr(newdata) );
11004 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
11005 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ) );
11052 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
11053 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ),
11055 binop(Iop_Or32, mkexpr(t4), mkexpr(t5)),
11056 binop(Iop_Or32, mkexpr(t6), mkexpr(t7)) ) ) );
11077 putIReg32( rG, binop(Iop_Or32, mkexpr(t0), mkexpr(t1) ) );
11107 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
11108 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ) );
11155 loadLE(Ity_V128, mkexpr(addr)) );
11178 loadLE(Ity_I64, mkexpr(addr)) );
11200 loadLE(Ity_I32, mkexpr(addr)) );
11220 loadLE(Ity_V128, mkexpr(addr)) );
11243 storeLE( mkexpr(addr),
11259 storeLE( mkexpr(addr),
11279 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
11294 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
11316 loadLE(Ity_I64, mkexpr(addr)) );
11338 loadLE(Ity_I64, mkexpr(addr)) );
11354 storeLE( mkexpr(addr),
11371 storeLE( mkexpr(addr),
11402 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11408 putXMMReg( rG, mkexpr(res) );
11430 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11436 putXMMReg( rG, mkexpr(res) );
11454 loadLE(Ity_I64, mkexpr(addr)) );
11475 loadLE(Ity_I64, mkexpr(addr)) );
11491 storeLE( mkexpr(addr),
11508 storeLE( mkexpr(addr),
11564 loadLE(Ity_V128, mkexpr(addr)) );
11585 loadLE(Ity_V128, mkexpr(addr)) );
11609 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
11629 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
11654 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11665 mkexpr(rmode),
11667 unop(Iop_64to32, mkexpr(arg64)) )) );
11672 mkexpr(rmode),
11674 unop(Iop_64HIto32, mkexpr(arg64)) )) );
11694 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
11702 mkexpr(rmode),
11703 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
11714 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11722 mkexpr(rmode),
11723 binop(Iop_I64StoF64, mkexpr(rmode), mkexpr(arg64)) ) );
11742 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
11748 unop(Iop_I32StoF64, mkexpr(arg32))
11760 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11770 mkexpr(arg64)
11796 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11804 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)) )
11809 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)) )
11825 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
11861 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
11863 mkexpr(addr),
11881 mkexpr(rmode),
11882 unop( Iop_F32toF64, mkexpr(f32hi) ) ),
11884 mkexpr(rmode),
11885 unop( Iop_F32toF64, mkexpr(f32lo) ) )
11889 putMMXReg(gregLO3ofRM(modrm), mkexpr(dst64));
11947 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
11949 mkexpr(addr),
11966 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64hi) ),
11967 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo) )
11971 putMMXReg(gregLO3ofRM(modrm), mkexpr(dst64));
12212 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
12219 unop( Iop_F32toF64, mkexpr(f32lo) ) );
12237 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
12246 binop( Iop_F64toF32, mkexpr(rmode), mkexpr(f64lo) )
12543 ? unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)) )
12544 : unop( Iop_64UtoV128,loadLE(Ity_I64, mkexpr(addr)) )
12568 loadLE(Ity_V128, mkexpr(addr)) );
12587 loadLE(Ity_V128, mkexpr(addr)) );
12622 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12636 putMMXReg(gregLO3ofRM(modrm), mkexpr(dV));
12716 putXMMReg(reg, mkexpr(math_PSRLDQ( sV, imm )));
12731 putXMMReg(reg, mkexpr(math_PSLLDQ( sV, imm )));
12795 loadLE(Ity_I64, mkexpr(addr)) );
12823 storeLE( mkexpr(addr),
12848 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12866 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12920 mkexpr(addr),
12971 mkIRExprVec_1( mkexpr(addr) )
12977 d->mAddr = mkexpr(addr);
13050 mkIRExprVec_1( mkexpr(addr) )
13056 d->mAddr = mkexpr(addr);
13139 storeLE( mkexpr(addr), getIRegG(sz, pfx, modrm) );
13179 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
13192 putMMXReg(gregLO3ofRM(modrm), mkexpr(t6));
13215 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
13222 putXMMReg(rG, mkexpr(res_vec));
13240 case 0: assign(t5, mkexpr(t0)); break;
13241 case 1: assign(t5, mkexpr(t1)); break;
13242 case 2: assign(t5, mkexpr(t2)); break;
13243 case 3: assign(t5, mkexpr(t3)); break;
13247 putIReg64(gregOfRexRM(pfx,modrm), unop(Iop_16Uto64, mkexpr(t5)));
13249 putIReg32(gregOfRexRM(pfx,modrm), unop(Iop_16Uto32, mkexpr(t5)));
13293 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13299 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
13320 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13329 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
13410 storeLE( mkexpr(addr),
13460 mkIRExprVec_1(mkexpr(t0))));
13461 putIReg32(gregOfRexRM(pfx,modrm), unop(Iop_64to32,mkexpr(t1)));
13665 storeLE( mkexpr(addr), getMMXReg(gregLO3ofRM(modrm)) );
13679 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
13816 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13820 putXMMReg( rG, mkexpr(math_PMULUDQ_128( sV, dV )) );
13843 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13849 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
13850 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
13852 binop( Iop_MullU32, mkexpr(t0), mkexpr(t1) ) );
13872 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13877 putXMMReg( rG, mkexpr(math_PMADDWD_128(dV, sV)) );
13905 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13910 putXMMReg( rG, mkexpr( math_PSADBW_128 ( dV, sV ) ) );
14039 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
14042 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
14048 ( rG, binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
14071 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
14073 mkexpr(addr), mkU64(16))) );
14077 putYMMRegLane64( rG, 0, mkexpr(d0) );
14078 putYMMRegLane64( rG, 1, mkexpr(d0) );
14079 putYMMRegLane64( rG, 2, mkexpr(d1) );
14080 putYMMRegLane64( rG, 3, mkexpr(d1) );
14106 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14138 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
14167 mkexpr(leftV), mkexpr(rightV) ) );
14182 assign( leftV, binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
14183 assign( rightV, binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
14187 mkexpr(leftV), mkexpr(rightV) ) );
14255 mkexpr(addr)) );
14261 putXMMReg( rG, mkexpr( math_HADDPS_128 ( gV, eV, isAdd ) ) );
14280 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14286 putXMMReg( rG, mkexpr( math_HADDPD_128 ( gV, eV, isAdd ) ) );
14305 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14311 putXMMReg( rG, mkexpr( math_ADDSUBPD_128 ( gV, eV ) ) );
14329 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14335 putXMMReg( rG, mkexpr( math_ADDSUBPS_128 ( gV, eV ) ) );
14349 loadLE(Ity_V128, mkexpr(addr)) );
14399 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
14400 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
14401 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
14402 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
14415 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sHi),mkU8(7))));
14420 binop(Iop_ShlN8x8,mkexpr(sHi),mkU8(4)),
14423 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
14430 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7hi)),
14431 mkexpr(maskBit3hi)),
14433 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7hi)),
14434 unop(Iop_Not64,mkexpr(maskBit3hi))) ));
14436 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
14442 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sLo),mkU8(7))));
14447 binop(Iop_ShlN8x8,mkexpr(sLo),mkU8(4)),
14450 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
14457 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7lo)),
14458 mkexpr(maskBit3lo)),
14460 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7lo)),
14461 unop(Iop_Not64,mkexpr(maskBit3lo))) ));
14463 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
14465 assign(res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
14515 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14520 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
14521 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
14522 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
14523 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
14533 binop(opCatE,mkexpr(sHi),mkexpr(sLo)),
14534 binop(opCatO,mkexpr(sHi),mkexpr(sLo)) ),
14536 binop(opCatE,mkexpr(dHi),mkexpr(dLo)),
14537 binop(opCatO,mkexpr(dHi),mkexpr(dLo)) ) ) );
14549 assign( sVoddsSX, binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
14551 binop(Iop_ShlN16x8, mkexpr(sV), mkU8(8)),
14553 assign( dVoddsZX, binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
14555 binop(Iop_ShlN16x8, mkexpr(dV), mkU8(8)),
14560 binop(Iop_Mul16x8, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
14561 binop(Iop_Mul16x8, mkexpr(sVevensSX), mkexpr(dVevensZX))
14604 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14611 putXMMReg(gregOfRexRM(pfx,modrm), mkexpr(res));
14630 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14643 mkexpr(dV),
14644 binop(Iop_And64, mkexpr(sV), mkU64(0x0707070707070707ULL))
14647 unop(Iop_Not64, binop(Iop_SarN8x8, mkexpr(sV), mkU8(7)))
14724 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14733 binop(opCatE,mkexpr(sV),mkexpr(dV)),
14734 binop(opCatO,mkexpr(sV),mkexpr(dV))
14761 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14766 putXMMReg( rG, mkexpr( math_PMADDUBSW_128( dV, sV ) ) );
14790 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14798 binop(Iop_SarN16x4, mkexpr(sV), mkU8(8)) );
14801 binop(Iop_ShlN16x4, mkexpr(sV), mkU8(8)),
14804 binop(Iop_ShrN16x4, mkexpr(dV), mkU8(8)) );
14807 binop(Iop_ShlN16x4, mkexpr(dV), mkU8(8)),
14813 binop(Iop_Mul16x4, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
14814 binop(Iop_Mul16x4, mkexpr(sVevensSX), mkexpr(dVevensZX))
14856 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14862 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
14863 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
14864 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
14865 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
14870 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
14871 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
14903 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14911 dis_PSIGN_helper( mkexpr(sV), mkexpr(dV), laneszB )
14940 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14946 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
14947 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
14948 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
14949 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
14954 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
14955 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
14977 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14985 dis_PMULHRSW_helper( mkexpr(sV), mkexpr(dV) )
15019 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15026 mkexpr(math_PABS_XMM(sV, laneszB)) );
15054 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15061 mkexpr(math_PABS_MMX( sV, laneszB )) );
15126 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15135 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
15157 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15166 assign( res, mkexpr(sV) );
15171 binop(Iop_Shr64, mkexpr(sV), mkU8(8*d64)),
15172 binop(Iop_Shl64, mkexpr(dV), mkU8(8*(8-d64))
15176 mkexpr(dV) );
15179 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d64-8))) );
15187 putMMXReg( gregLO3ofRM(modrm), mkexpr(res) );
15249 assign(src, loadLE(ty, mkexpr(addr)));
15256 putIRegG(sz, pfx, modrm, mkexpr(result));
15268 widenUto64(mkexpr(src)),
15295 assign(src, loadLE(ty, mkexpr(addr)));
15302 putIRegG(sz, pfx, modrm, mkexpr(res));
15310 assign(src64, widenUto64(mkexpr(src)));
15311 assign(res64, widenUto64(mkexpr(res)));
15319 binop(Iop_CmpEQ64, mkexpr(res64), mkU64(0))),
15323 binop(Iop_CmpEQ64, mkexpr(src64), mkU64(0))),
15331 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
15369 assign(mask, binop(opSAR, mkexpr(vec0), mkexpr(sh)));
15372 assign(notmask, unop(Iop_NotV128, mkexpr(mask)));
15376 binop(Iop_AndV128, mkexpr(vecE), mkexpr(mask)),
15377 binop(Iop_AndV128, mkexpr(vecG), mkexpr(notmask))));
15397 binop(opSAR128, mkexpr(vec0Hi), mkexpr(sh)),
15398 binop(opSAR128, mkexpr(vec0Lo), mkexpr(sh))));
15401 assign(notmask, unop(Iop_NotV256, mkexpr(mask)));
15405 binop(Iop_AndV256, mkexpr(vecE), mkexpr(mask)),
15406 binop(Iop_AndV256, mkexpr(vecG), mkexpr(notmask))));
15435 assign(vecE, loadLE(Ity_V128, mkexpr(addr)));
15445 putYMMRegLoAndZU( rG, mkexpr(res) );
15474 assign(vecE, loadLE(Ity_V256, mkexpr(addr)));
15484 putYMMReg( rG, mkexpr(res) );
15514 mkexpr(andV), mkexpr(andV)),
15516 mkexpr(andV), mkexpr(andV)))));
15522 mkexpr(andnV), mkexpr(andnV)),
15524 mkexpr(andnV), mkexpr(andnV)))));
15533 binop(Iop_Sar64, mkexpr(and64), mkU8(63))));
15537 binop(Iop_Sar64, mkexpr(andn64), mkU8(63))));
15546 assign(t1, binop(Iop_And64, mkexpr(and64), mkexpr(t0)));
15547 assign(t2, binop(Iop_And64, mkexpr(andn64), mkexpr(t0)));
15560 binop(Iop_Sub64, mkU64(0), mkexpr(and64)),
15561 mkexpr(and64)), mkU8(63))));
15567 binop(Iop_Sub64, mkU64(0), mkexpr(andn64)),
15568 mkexpr(andn64)), mkU8(63))));
15576 binop(Iop_And64, mkexpr(z64), mkU64(AMD64G_CC_MASK_Z)),
15577 binop(Iop_And64, mkexpr(c64), mkU64(AMD64G_CC_MASK_C))));
15579 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(newOSZACP)));
15611 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
15628 assign(andV, binop(Iop_AndV128, mkexpr(vecE), mkexpr(vecG)));
15630 mkexpr(vecE),
15631 binop(Iop_XorV128, mkexpr(vecG),
15661 assign(vecE, loadLE( Ity_V256, mkexpr(addr) ));
15677 assign(andV, binop(Iop_AndV256, mkexpr(vecE), mkexpr(vecG)));
15679 mkexpr(vecE), unop(Iop_NotV256, mkexpr(vecG))));
15690 assign( andV128, binop( Iop_OrV128, mkexpr(andVhi), mkexpr(andVlo) ) );
15691 assign( andnV128, binop( Iop_OrV128, mkexpr(andnVhi), mkexpr(andnVlo) ) );
15718 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
15726 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) )
15731 mkexpr(srcVec) ),
15761 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
15768 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) );
15798 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
15806 unop( Iop_32HIto16, mkexpr(srcBytes) ) ),
15808 unop( Iop_32to16, mkexpr(srcBytes) ) ) ) );
15832 unop( Iop_32UtoV128, loadLE( Ity_I32, mkexpr(addr) ) ) );
15842 mkexpr(zeroVec),
15844 mkexpr(zeroVec), mkexpr(srcVec) ) ) );
15869 assign( srcI64, unop(Iop_V128to64, mkexpr(srcVec)) );
15874 assign( srcI64, loadLE(Ity_I64, mkexpr(addr)) );
15875 assign( srcVec, unop( Iop_64UtoV128, mkexpr(srcI64)) );
15883 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) )
15886 unop( Iop_64HIto32, mkexpr(srcI64) ) ),
15888 unop( Iop_64to32, mkexpr(srcI64) ) ) );
15916 unop( Iop_32UtoV128, loadLE( Ity_I32, mkexpr(addr) ) ) );
15926 mkexpr(zeroVec),
15928 mkexpr(zeroVec), mkexpr(srcVec)));
15957 assign( srcBytes, loadLE( Ity_I16, mkexpr(addr) ) );
15965 unop( Iop_16HIto8, mkexpr(srcBytes) ) ),
15967 unop( Iop_16to8, mkexpr(srcBytes) ) ) ) );
15992 unop( Iop_16Uto32, loadLE( Ity_I16, mkexpr(addr) ))));
16002 mkexpr(zeroVec),
16004 mkexpr(zeroVec),
16006 mkexpr(zeroVec), mkexpr(srcVec) ) ) ) );
16033 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16037 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
16038 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
16043 mkIRExprVec_2( mkexpr(sLo), mkexpr(sHi) )
16046 (rG, unop(Iop_64UtoV128, mkexpr(dLo)));
16075 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
16166 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
16271 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
16281 putXMMReg(gregOfRexRM(pfx, modrm), mkexpr(res));
16374 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16379 putXMMReg( rG, mkexpr(math_PMULDQ_128( dV, sV )) );
16414 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
16424 mkexpr(argL), mkexpr(argR)) );
16597 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
16606 binop( Iop_Mul32x4, mkexpr(argL), mkexpr(argR)) );
16663 assign(valE, loadLE(tyE, mkexpr(addr)));
16693 mkIRExprVec_2(mkexpr(valG0),
16694 widenUto64(mkexpr(valE)))));
16696 putIRegG(4, pfx, modrm, unop(Iop_64to32, mkexpr(valG1)));
16751 case 0: assign(d16, unop(Iop_32to16, mkexpr(t0))); break;
16752 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(t0))); break;
16753 case 2: assign(d16, unop(Iop_32to16, mkexpr(t1))); break;
16754 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(t1))); break;
16755 case 4: assign(d16, unop(Iop_32to16, mkexpr(t2))); break;
16756 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(t2))); break;
16757 case 6: assign(d16, unop(Iop_32to16, mkexpr(t3))); break;
16758 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(t3))); break;
16764 putIReg32( rE, unop(Iop_16Uto32, mkexpr(d16)) );
16769 storeLE( mkexpr(addr), mkexpr(d16) );
16807 case 0: assign( src_dword, mkexpr(t0) ); break;
16808 case 1: assign( src_dword, mkexpr(t1) ); break;
16809 case 2: assign( src_dword, mkexpr(t2) ); break;
16810 case 3: assign( src_dword, mkexpr(t3) ); break;
16815 putIReg32( eregOfRexRM(pfx,modrm), mkexpr(src_dword) );
16821 storeLE( mkexpr(addr), mkexpr(src_dword) );
16855 case 0: assign( src_qword, unop(Iop_V128to64, mkexpr(xmm_vec)) );
16857 case 1: assign( src_qword, unop(Iop_V128HIto64, mkexpr(xmm_vec)) );
16863 putIReg64( eregOfRexRM(pfx,modrm), mkexpr(src_qword) );
16869 storeLE( mkexpr(addr), mkexpr(src_qword) );
16910 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
16980 binop(Iop_Shr64, mkexpr(resT), mkU8(16)),
16990 binop(Iop_And64, mkexpr(resT), mkU64(0xFFFF))
17019 unop(Iop_8Uto64, mkexpr(u8)),
17022 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
17024 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
17030 mkexpr(tmp128),
17031 binop(Iop_AndV128, mkexpr(v128), mkV128(mask))) );
17063 mkexpr(withZs),
17064 binop( Iop_AndV128, mkexpr(v128), mkV128(mask) ) ) );
17077 assign(withZs, binop(Iop_64HLtoV128, mkU64(0), mkexpr(u64)));
17081 assign( withZs, binop(Iop_64HLtoV128, mkexpr(u64), mkU64(0)));
17086 mkexpr(withZs),
17087 binop( Iop_AndV128, mkexpr(v128), mkV128(mask) ) ) );
17138 case 0: assign( sel_lane, mkexpr(t0) ); break;
17139 case 1: assign( sel_lane, mkexpr(t1) ); break;
17140 case 2: assign( sel_lane, mkexpr(t2) ); break;
17141 case 3: assign( sel_lane, mkexpr(t3) ); break;
17145 binop( Iop_Shr32, mkexpr(sel_lane), mkU8(((imm8 & 3)*8)) ) );
17150 binop(Iop_And32, mkexpr(shr_lane), mkU32(255)) ) );
17156 storeLE( mkexpr(addr), unop(Iop_32to8, mkexpr(shr_lane) ) );
17174 mkexpr(dst_vec), mkexpr(src_vec) ),
17179 mkexpr(and_vec), mkexpr(and_vec) ),
17181 mkexpr(and_vec), mkexpr(and_vec) ) ) );
17185 mkexpr(sum_vec), mkexpr(sum_vec) ),
17206 binop( Iop_Mul32Fx4, mkexpr(dst_vec),
17207 mkexpr(src_vec) ),
17214 mkexpr(prod_vec), mkexpr(prod_vec) ),
17216 mkexpr(prod_vec), mkexpr(prod_vec) ) ) );
17222 mkexpr(sum_vec), mkexpr(sum_vec) ),
17224 mkexpr(sum_vec), mkexpr(sum_vec) ) ),
17246 assign(src_masked, binop(Iop_AndV128, mkexpr(src_vec), mkexpr(src_maskV)));
17247 assign(dst_masked, binop(Iop_AndV128, mkexpr(dst_vec), mkexpr(dst_maskV)));
17252 assign( sHi, unop(Iop_V128HIto64, mkexpr(src_masked)) );
17253 assign( sLo, unop(Iop_V128to64, mkexpr(src_masked)) );
17257 assign( dHi, unop(Iop_V128HIto64, mkexpr(dst_masked)) );
17258 assign( dLo, unop(Iop_V128to64, mkexpr(dst_masked)) );
17265 = mkIRExprVec_5( mkexpr(sHi), mkexpr(sLo), mkexpr(dHi), mkexpr(dLo),
17268 = mkIRExprVec_5( mkexpr(sHi), mkexpr(sLo), mkexpr(dHi), mkexpr(dLo),
17279 assign(res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo)));
17308 case 0: assign( src_dword, mkexpr(t0) ); break;
17309 case 1: assign( src_dword, mkexpr(t1) ); break;
17310 case 2: assign( src_dword, mkexpr(t2) ); break;
17311 case 3: assign( src_dword, mkexpr(t3) ); break;
17317 putIReg32( rE, mkexpr(src_dword) );
17322 storeLE( mkexpr(addr), mkexpr(src_dword) );
17337 mkexpr(dV)));
17339 mkexpr(sV)));
17346 args = mkIRExprVec_3(mkexpr(t0), mkexpr(t1), mkU64(0));
17349 args = mkIRExprVec_3(mkexpr(t0), mkexpr(t1), mkU64(1));
17354 assign(res, binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)));
17413 binop(Iop_Add64, mkexpr(addr), mkU64(0) )));
17415 binop(Iop_Add64, mkexpr(addr), mkU64(4) )));
17417 binop(Iop_Add64, mkexpr(addr), mkU64(8) )));
17419 binop(Iop_Add64, mkexpr(addr), mkU64(12) )));
17433 assign(res0, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src0)) );
17434 assign(res1, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src1)) );
17435 assign(res2, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src2)) );
17436 assign(res3, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src3)) );
17438 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 0, mkexpr(res0) );
17439 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 1, mkexpr(res1) );
17440 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 2, mkexpr(res2) );
17441 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 3, mkexpr(res3) );
17475 binop(Iop_Add64, mkexpr(addr), mkU64(0) )));
17477 binop(Iop_Add64, mkexpr(addr), mkU64(8) )));
17491 assign(res0, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src0)) );
17492 assign(res1, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src1)) );
17494 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 0, mkexpr(res0) );
17495 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 1, mkexpr(res1) );
17528 mkexpr(addr) ));
17544 mkexpr(src)) );
17547 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 0, mkexpr(res) );
17549 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 0, mkexpr(res) );
17579 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17587 mkexpr( math_BLENDPS_128( src_vec, dst_vec, imm8) ) );
17615 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17623 mkexpr( math_BLENDPD_128( src_vec, dst_vec, imm8) ) );
17652 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17660 mkexpr( math_PBLENDW_128( src_vec, dst_vec, imm8) ) );
17736 assign( new8, loadLE( Ity_I8, mkexpr(addr) ) );
17744 putXMMReg( rG, mkexpr(res) );
17773 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
17783 putXMMReg( rG, mkexpr(math_INSERTPS( vG, d2ins, imm8 )) );
17808 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
17817 putXMMReg( rG, mkexpr(res_vec) );
17839 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
17848 putXMMReg( rG, mkexpr(res_vec) );
17874 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17881 putXMMReg( rG, mkexpr(res) );
17907 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17914 putXMMReg( rG, mkexpr(res) );
17943 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
17949 putXMMReg( rG, mkexpr( math_MPSADBW_128(dst_vec, src_vec, imm8) ) );
17980 assign( svec, loadLE( Ity_V128, mkexpr(addr) ) );
17987 putXMMReg( rG, mkexpr( math_PCLMULQDQ(dvec, svec, imm8) ) );
18310 putIReg64(R_RSP, mkexpr(t2) );
18311 storeLE(mkexpr(t2),mkexpr(t1));
18330 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
18331 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t2), mkU64(sz)));
18332 putIRegRexB(sz, pfx, opc-0x58, mkexpr(t1));
18356 loadLE(Ity_I32, mkexpr(addr))));
18389 putIReg64(R_RSP, mkexpr(t1) );
18394 storeLE( mkexpr(t1), mkU(ty,d64) );
18531 putIRegG(sz, pfx, modrm, mkexpr(t1));
18532 putIRegE(sz, pfx, modrm, mkexpr(t2));
18540 assign( t1, loadLE(ty, mkexpr(addr)) );
18542 casLE( mkexpr(addr),
18543 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
18544 putIRegG( sz, pfx, modrm, mkexpr(t1) );
18588 ? unop(Iop_64to32, mkexpr(addr))
18589 : mkexpr(addr)
18617 assign( t3, loadLE(Ity_I64, mkexpr(t1)) );
18624 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t1), mkU64(sz)) );
18627 storeLE( mkexpr(addr), mkexpr(t3) );
18715 putIReg64(R_RSP, mkexpr(t1) );
18724 mkexpr(t2),
18733 mkexpr(t3),
18743 mkexpr(t4),
18752 storeLE( mkexpr(t1), unop(Iop_32to16,
18753 unop(Iop_64to32,mkexpr(t5))) );
18755 storeLE( mkexpr(t1), mkexpr(t5) );
18770 assign(t1, widenUto64(loadLE(szToITy(sz),mkexpr(t2))));
18771 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t2), mkU64(sz)));
18778 mkexpr(t1),
18794 binop(Iop_Shr64, mkexpr(t1), mkU8(10)),
18807 binop(Iop_Shr64, mkexpr(t1), mkU8(21)),
18820 binop(Iop_Shr64, mkexpr(t1), mkU8(18)),
18851 putIRegRAX(sz, loadLE( ty, mkexpr(addr) ));
18869 storeLE( mkexpr(addr), getIRegRAX(sz) );
19084 storeLE(mkexpr(addr),
19112 putIReg64(R_RSP, mkexpr(t2));
19113 storeLE(mkexpr(t2), mkexpr(t1));
19114 putIReg64(R_RBP, mkexpr(t2));
19116 putIReg64(R_RSP, binop(Iop_Sub64, mkexpr(t2), mkU64(d64)));
19132 putIReg64(R_RSP, mkexpr(t1));
19133 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
19134 putIReg64(R_RBP, mkexpr(t2));
19135 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t1), mkU64(8)) );
19368 mkIRExprVec_2( mkexpr(t1), mkU64(sz) )
19372 putIRegRAX(sz, narrowTo( ty, mkexpr(t2) ) );
19415 mkIRExprVec_3( mkexpr(t1),
19430 putIReg64(R_RSP, mkexpr(t1));
19431 storeLE( mkexpr(t1), mkU64(guest_RIP_bbstart+delta));
19486 assign( t2, binop(Iop_Xor64, mkexpr(t1),
19491 assign( t2, binop(Iop_And64, mkexpr(t1),
19496 assign( t2, binop(Iop_Or64, mkexpr(t1),
19505 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t2) ));
19584 binop(Iop_And64,mkexpr(t1),mkexpr(m8)),
19587 binop(Iop_Shl64,mkexpr(t1),mkU8(8)),
19588 mkexpr(m8))
19596 binop(Iop_And64,mkexpr(s8),mkexpr(m16)),
19599 binop(Iop_Shl64,mkexpr(s8),mkU8(16)),
19600 mkexpr(m16))
19608 binop(Iop_And64,mkexpr(s16),mkexpr(m32)),
19611 binop(Iop_Shl64,mkexpr(s16),mkU8(32)),
19612 mkexpr(m32))
19621 binop(Iop_Shl32, mkexpr(t1), mkU8(24)),
19624 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t1), mkU8(8)),
19627 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(8)),
19629 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(24)),
19638 binop(Iop_Shl16, mkexpr(t1), mkU8(8)),
19639 binop(Iop_Shr16, mkexpr(t1), mkU8(8)) ));
19698 mkIRExprVec_2( mkexpr(addr),
19703 d->mAddr = mkexpr(addr);
19717 stmt( IRStmt_Exit(binop(Iop_CmpNE32, mkexpr(t1), mkU32(0)),
19787 putIRegRDX(4, unop(Iop_64HIto32, mkexpr(val)));
19788 putIRegRAX(4, unop(Iop_64to32, mkexpr(val)));
19911 putIRegE(1, pfx, modrm, mkexpr(t1));
19917 storeLE( mkexpr(addr), mkexpr(t1) );
20175 assign( expdHi, sz==4 ? unop(Iop_64to32, mkexpr(expdHi64))
20176 : mkexpr(expdHi64) );
20177 assign( expdLo, sz==4 ? unop(Iop_64to32, mkexpr(expdLo64))
20178 : mkexpr(expdLo64) );
20185 Iend_LE, mkexpr(addr),
20186 mkexpr(expdHi), mkexpr(expdLo),
20187 mkexpr(dataHi), mkexpr(dataLo)
20194 binop(opXOR, mkexpr(oldHi), mkexpr(expdHi)),
20195 binop(opXOR, mkexpr(oldLo), mkexpr(expdLo))
20217 IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(success)),
20218 sz == 4 ? unop(Iop_32Uto64, mkexpr(oldHi))
20219 : mkexpr(oldHi),
20220 mkexpr(expdHi64)
20223 IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(success)),
20224 sz == 4 ? unop(Iop_32Uto64, mkexpr(oldLo))
20225 : mkexpr(oldLo),
20226 mkexpr(expdLo64)
20235 mkexpr(flags_old),
20239 unop(Iop_1Uto64, mkexpr(success)), mkU64(1)),
20243 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(flags_new) ));
20272 putIRegRexB(4, pfx, opc-0xC8, mkexpr(t2));
20281 putIRegRexB(8, pfx, opc-0xC8, mkexpr(t2));
20469 assign(src, loadLE(ty, mkexpr(addr)));
20471 putIRegG(sz, pfx, modrm, mkexpr(dst));
20476 storeLE(mkexpr(addr), mkexpr(dst));
20608 assign(tSR, loadLE(Ity_V128, mkexpr(addr)));
20617 assign(res, swapArgs ? binop(op, mkexpr(tSR), mkexpr(tSL))
20618 : binop(op, mkexpr(tSL), mkexpr(tSR)));
20624 putYMMRegLoAndZU(rD, mkexpr(res));
20687 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
20692 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
20713 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size))),
20715 binop(op, mkexpr(g0), mkexpr(amt8))
20724 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size))),
20725 binop(op, mkexpr(g0), mkU8(size-1)),
20726 binop(op, mkexpr(g0), mkexpr(amt8))
20733 putYMMRegLoAndZU( rG, mkexpr(g1) );
20778 : binop(op, mkexpr(e0), mkU8(amt))
20783 ? binop(op, mkexpr(e0), mkU8(size-1))
20784 : binop(op, mkexpr(e0), mkU8(amt))
20790 putYMMRegLoAndZU( rD, mkexpr(e1) );
20826 loadLE(Ity_I64, mkexpr(addr))) );
20827 putXMMReg( rG, binop(op, vpart, mkexpr(epart)) );
20867 assign(e64, loadLE(Ity_I64, mkexpr(addr)));
20877 getXMMReg(rV), mkexpr(e64)));
20879 putYMMRegLoAndZU( rG, unop(op, mkexpr(arg)) );
20914 assign(e32, loadLE(Ity_I32, mkexpr(addr)));
20924 getXMMReg(rV), mkexpr(e32)));
20926 putYMMRegLoAndZU( rG, unop(op, mkexpr(arg)) );
20963 loadLE(Ity_I32, mkexpr(addr))) );
20964 putXMMReg( rG, binop(op, vpart, mkexpr(epart)) );
21033 all_lanes ? loadLE(Ity_V128, mkexpr(addr))
21034 : sz == 8 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
21035 : /*sz==4*/ unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr))));
21041 assign(plain, preSwap ? binop(op, mkexpr(argR), mkexpr(argL))
21042 : binop(op, mkexpr(argL), mkexpr(argR)));
21048 putYMMRegLoAndZU( rG, unop(Iop_NotV128, mkexpr(plain)) );
21050 putYMMRegLoAndZU( rG, mkexpr(plain) );
21061 putYMMRegLoAndZU( rG, binop(Iop_XorV128, mkexpr(plain),
21064 putYMMRegLoAndZU( rG, mkexpr(plain) );
21082 unop(Iop_NotV128, mkexpr(plain)),
21083 mkexpr(mask)),
21084 binop(Iop_AndV128, mkexpr(argL), mkexpr(notMask))));
21089 mkexpr(plain),
21090 mkexpr(mask)),
21091 binop(Iop_AndV128, mkexpr(argL), mkexpr(notMask))));
21093 putYMMRegLoAndZU( rG, mkexpr(res) );
21148 assign(argR, loadLE(Ity_V256, mkexpr(addr)) );
21157 binop(op, mkexpr(argLhi), mkexpr(argRhi)),
21158 binop(op, mkexpr(argLlo), mkexpr(argRlo)) ) );
21163 putYMMReg( rG, unop(Iop_NotV256, mkexpr(plain)) );
21165 putYMMReg( rG, mkexpr(plain) );
21195 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
21200 putYMMRegLoAndZU( rG, mkexpr(res) );
21226 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
21230 putYMMRegLoAndZU( rG, unop(op, mkexpr(arg)) );
21270 assign(tSR, loadLE(Ity_V256, mkexpr(addr)));
21279 assign(res, swapArgs ? binop(op, mkexpr(tSR), mkexpr(tSL))
21280 : binop(op, mkexpr(tSL), mkexpr(tSR)));
21286 putYMMReg(rD, mkexpr(res));
21344 assign(arg, loadLE(Ity_V256, mkexpr(addr)));
21348 putYMMReg( rG, unop(op, mkexpr(arg)) );
21372 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
21382 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s3))),
21383 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s2))),
21384 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s1))),
21385 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s0)))
21409 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
21418 # define CVT(_t) binop( Iop_F64toF32, mkexpr(rmode), \
21419 unop(Iop_ReinterpI64asF64, mkexpr(_t)) )
21463 putXMMReg( rG, mkexpr(z128) );
21465 putXMMRegLane64( rG, 0, loadLE(Ity_I64, mkexpr(addr)) );
21466 putYMMRegLane128( rG, 1, mkexpr(z128) );
21485 putYMMRegLoAndZU(rG, mkexpr(res));
21498 putXMMReg( rG, mkexpr(z128) );
21500 putXMMRegLane32( rG, 0, loadLE(Ity_I32, mkexpr(addr)) );
21501 putYMMRegLane128( rG, 1, mkexpr(z128) );
21522 putYMMRegLoAndZU(rG, mkexpr(res));
21537 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
21554 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
21571 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
21588 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
21604 storeLE( mkexpr(addr), getXMMRegLane64(rG, 0));
21623 putYMMRegLoAndZU(rG, mkexpr(res));
21634 storeLE( mkexpr(addr), getXMMRegLane32(rG, 0));
21655 putYMMRegLoAndZU(rG, mkexpr(res));
21670 storeLE( mkexpr(addr), getXMMReg(rG) );
21687 storeLE( mkexpr(addr), getYMMReg(rG) );
21704 storeLE( mkexpr(addr), getXMMReg(rG) );
21721 storeLE( mkexpr(addr), getYMMReg(rG) );
21755 putYMMRegLoAndZU(rG, mkexpr(res));
21775 loadLE(Ity_I64, mkexpr(addr))));
21776 putYMMRegLoAndZU(rG, mkexpr(res));
21804 storeLE( mkexpr(addr), getXMMRegLane64( rG, 0));
21830 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
21836 putYMMRegLoAndZU( rG, mkexpr(res) );
21858 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
21864 putYMMReg( rG, mkexpr(res) );
21886 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
21892 putYMMRegLoAndZU( rG, mkexpr(res) );
21914 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
21920 putYMMReg( rG, mkexpr(res) );
21942 putYMMRegLoAndZU(rG, mkexpr(res));
21961 loadLE(Ity_I64, mkexpr(addr)),
21963 putYMMRegLoAndZU(rG, mkexpr(res));
21991 storeLE( mkexpr(addr), getXMMRegLane64( rG, 1));
22011 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
22029 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
22047 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
22065 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
22086 mkexpr(addr), getXMMReg(rG) );
22104 storeLE( mkexpr(addr), getYMMReg(rG) );
22123 storeLE( mkexpr(addr), getXMMReg(rG) );
22142 storeLE( mkexpr(addr), getYMMReg(rG) );
22167 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
22173 unop(Iop_I32StoF64, mkexpr(arg32)));
22193 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
22201 mkexpr(arg64)) );
22221 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
22228 mkexpr(rmode),
22229 binop(Iop_I64StoF64, mkexpr(rmode),
22230 mkexpr(arg64)) ) );
22251 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
22258 mkexpr(rmode),
22259 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
22281 storeLE(mkexpr(addr), mkexpr(tS));
22297 storeLE(mkexpr(addr), mkexpr(tS));
22708 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)) );
22714 binop( Iop_F64toF32, mkexpr(rmode),
22715 mkexpr(f64lo)) );
22736 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)) );
22742 unop( Iop_F32toF64, mkexpr(f32lo)) );
23124 unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)))
23149 unop( Iop_64UtoV128,loadLE(Ity_I64, mkexpr(addr)))
23178 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
23181 putYMMReg(rD, mkexpr(tD));
23203 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
23206 putYMMRegLoAndZU(rD, mkexpr(tD));
23304 putYMMRegLoAndZU(rD, mkexpr(math_PSRLDQ( vecS, imm )));
23313 putYMMRegLoAndZU(rD, mkexpr(math_PSLLDQ( vecS, imm )));
23370 putYMMRegLane128(i, 1, mkexpr(zero128));
23381 putYMMRegLoAndZU(i, mkexpr(zero128));
23408 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
23414 putYMMRegLoAndZU( rG, mkexpr( math_HADDPS_128 ( dV, sV, isAdd ) ) );
23438 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
23447 mkexpr( math_HADDPS_128 ( d1, s1, isAdd ) ),
23448 mkexpr( math_HADDPS_128 ( d0, s0, isAdd ) ) ) );
23470 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
23476 putYMMRegLoAndZU( rG, mkexpr( math_HADDPD_128 ( dV, sV, isAdd ) ) );
23500 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
23509 mkexpr( math_HADDPD_128 ( d1, s1, isAdd ) ),
23510 mkexpr( math_HADDPD_128 ( d0, s0, isAdd ) ) ) );
23534 putXMMRegLane64( rG, 0, loadLE(Ity_I64, mkexpr(addr)) );
23557 storeLE( mkexpr(addr), getXMMRegLane64(rG, 0) );
23576 storeLE( mkexpr(addr), getXMMRegLane32(rG, 0) );
23598 putYMMReg(rD, mkexpr(tS));
23605 storeLE(mkexpr(addr), mkexpr(tS));
23623 putYMMRegLoAndZU(rD, mkexpr(tS));
23630 storeLE(mkexpr(addr), mkexpr(tS));
23738 assign( new16, loadLE( Ity_I16, mkexpr(addr) ));
23747 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
23785 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
23792 putYMMRegLoAndZU( rG, mkexpr(res) );
23815 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
23822 putYMMReg( rG, mkexpr(res) );
23845 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
23852 putYMMRegLoAndZU( rG, mkexpr(res) );
23875 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
23882 putYMMReg( rG, mkexpr(res) );
23983 storeLE( mkexpr(addr), getXMMRegLane64( rG, 0 ));
24173 storeLE( mkexpr(addr), getXMMReg(rG) );
24187 storeLE( mkexpr(addr), getYMMReg(rG) );
24281 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
24283 putYMMReg(rD, mkexpr(tD));
24294 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
24296 putYMMRegLoAndZU(rD, mkexpr(tD));
24465 binop(Iop_ShlN32x4, mkexpr(ctrlV), mkU8(30)),
24470 assign(res, binop(Iop_Perm32x4, mkexpr(dataV), cv1));
24483 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
24496 binop(Iop_And64, mkexpr(cHi), mkU64(2))),
24497 mkexpr(dLo), mkexpr(dHi) );
24500 binop(Iop_And64, mkexpr(cLo), mkU64(2))),
24501 mkexpr(dLo), mkexpr(dHi) );
24516 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
24623 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
24635 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
24636 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
24665 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
24677 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
24678 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
24705 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
24710 putYMMRegLoAndZU(rG, mkexpr(resV));
24732 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
24737 putYMMReg(rG, mkexpr(resV));
24762 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
24767 putYMMRegLoAndZU(rG, mkexpr(resV));
24789 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
24794 putYMMReg(rG, mkexpr(resV));
24850 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
24852 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
24853 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
24867 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
24869 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
24870 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
24871 mkexpr(t64), mkexpr(t64));
24888 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
24889 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
24890 mkexpr(t64), mkexpr(t64));
24907 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
24908 putYMMReg( rG, binop(Iop_V128HLtoV256, mkexpr(t128), mkexpr(t128)) );
25028 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
25030 putYMMRegLoAndZU(rD, mkexpr(tD));
25307 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
25314 IRExpr* res = binop(Iop_V128HLtoV256, mkexpr(dVhi), mkexpr(dVlo));
25337 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
25340 putYMMRegLoAndZU(rG, mkexpr ( math_VPERMILPS_128 ( sV, imm8 ) ) );
25365 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
25370 assign(s1, unop(Iop_V128HIto64, mkexpr(sV)));
25371 assign(s0, unop(Iop_V128to64, mkexpr(sV)));
25374 mkexpr((imm8 & (1<<1)) ? s1 : s0),
25375 mkexpr((imm8 & (1<<0)) ? s1 : s0)));
25376 putYMMRegLoAndZU(rG, mkexpr(dV));
25398 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
25406 mkexpr((imm8 & (1<<3)) ? s3 : s2),
25407 mkexpr((imm8 & (1<<2)) ? s3 : s2),
25408 mkexpr((imm8 & (1<<1)) ? s1 : s0),
25409 mkexpr((imm8 & (1<<0)) ? s1 : s0)));
25410 putYMMReg(rG, mkexpr(dV));
25444 mkexpr(addr), mkU64(0))));
25446 mkexpr(addr), mkU64(16))));
25451 putYMMRegLane128(rG, 0, mkexpr(SEL((imm8 >> 0) & 3)));
25452 putYMMRegLane128(rG, 1, mkexpr(SEL((imm8 >> 4) & 3)));
25486 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
25501 # define CVT(s) binop(Iop_RoundF32toInt, mkexpr(rm), \
25502 unop(Iop_ReinterpI32asF32, mkexpr(s)))
25538 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
25552 # define CVT(s) binop(Iop_RoundF32toInt, mkexpr(rm), \
25553 unop(Iop_ReinterpI32asF32, mkexpr(s)))
25589 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
25604 # define CVT(s) binop(Iop_RoundF64toInt, mkexpr(rm), \
25605 unop(Iop_ReinterpI64asF64, mkexpr(s)))
25635 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
25649 # define CVT(s) binop(Iop_RoundF64toInt, mkexpr(rm), \
25650 unop(Iop_ReinterpI64asF64, mkexpr(s)))
25686 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
25702 mkexpr(src)) );
25705 putXMMRegLane64F( rG, 0, mkexpr(res) );
25707 putXMMRegLane32F( rG, 0, mkexpr(res) );
25741 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
25745 mkexpr( math_BLENDPS_256( sE, sV, imm8) ) );
25772 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
25776 mkexpr( math_BLENDPS_128( sE, sV, imm8) ) );
25806 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
25810 mkexpr( math_BLENDPD_256( sE, sV, imm8) ) );
25837 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
25841 mkexpr( math_BLENDPD_128( sE, sV, imm8) ) );
25871 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
25875 mkexpr( math_PBLENDW_128( sE, sV, imm8) ) );
25903 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
25911 putYMMRegLoAndZU( rG, mkexpr(res) );
25980 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
25989 putYMMRegLane128(rG, ib & 1, mkexpr(t128));
26010 putYMMRegLoAndZU(rD, mkexpr(t128));
26018 storeLE(mkexpr(addr), mkexpr(t128));
26048 assign( src_u8, loadLE( Ity_I8, mkexpr(addr) ) );
26057 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26087 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
26097 putYMMRegLoAndZU( rG, mkexpr(math_INSERTPS( vV, d2ins, imm8 )) );
26123 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
26132 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26155 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
26164 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26188 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
26197 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26218 assign( dst_vec, loadLE( Ity_V256, mkexpr(addr) ) );
26231 mkexpr( math_DPPS_128(s1, d1, imm8) ),
26232 mkexpr( math_DPPS_128(s0, d0, imm8) ) ) );
26256 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
26265 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26295 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
26302 putYMMRegLoAndZU( rG, mkexpr( math_MPSADBW_128(dst_vec,
26336 assign( sV, loadLE( Ity_V128, mkexpr(addr) ) );
26343 putYMMRegLoAndZU( rG, mkexpr( math_PCLMULQDQ(dV, sV, imm8) ) );
26546 putIReg64(R_RSP, mkexpr(t2));
26547 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta));
27176 // assign(t[0], binop(Iop_Or64, mkexpr(src),
27177 // binop(Iop_Shr64, mkexpr(src), mkU8(1))));
27178 // assign(t[1], binop(Iop_Or64, mkexpr(t[0]),
27179 // binop(Iop_Shr64, mkexpr(t[0]), mkU8(2))));
27180 // assign(t[2], binop(Iop_Or64, mkexpr(t[1]),
27181 mkexpr(t[1]), mkU8(4))));
27182 // assign(t[3], binop(Iop_Or64, mkexpr(t[2]),
27183 // binop(Iop_Shr64, mkexpr(t[2]), mkU8(8))));
27184 // assign(t[4], binop(Iop_Or64, mkexpr(t[3]),
27185 // binop(Iop_Shr64, mkexpr(t[3]), mkU8(16))));
27186 // assign(t[5], binop(Iop_Or64, mkexpr(t[4]),
27187 // binop(Iop_Shr64, mkexpr(t[4]), mkU8(32))));
27188 // assign(t[6], unop(Iop_Not64, mkexpr(t[5])));
27192 // assign(t[0], binop(Iop_Or32, mkexpr(src),
27193 // binop(Iop_Shr32, mkexpr(src), mkU8(1))));
27194 // assign(t[1], binop(Iop_Or32, mkexpr(t[0]),
27195 // binop(Iop_Shr32, mkexpr(t[0]), mkU8(2))));
27196 // assign(t[2], binop(Iop_Or32, mkexpr(t[1]),
27197 // binop(Iop_Shr32, mkexpr(t[1]), mkU8(4))));
27198 // assign(t[3], binop(Iop_Or32, mkexpr(t[2]),
27199 // binop(Iop_Shr32, mkexpr(t[2]), mkU8(8))));
27200 // assign(t[4], binop(Iop_Or32, mkexpr(t[3]),
27201 // binop(Iop_Shr32, mkexpr(t[3]), mkU8(16))));
27202 // assign(t[5], unop(Iop_Not32, mkexpr(t[4])));
27206 // assign(t[0], binop(Iop_Or16, mkexpr(src),
27207 // binop(Iop_Shr16, mkexpr(src), mkU8(1))));
27208 // assign(t[1], binop(Iop_Or16, mkexpr(t[0]),
27209 // binop(Iop_Shr16, mkexpr(t[0]), mkU8(2))));
27210 // assign(t[2], binop(Iop_Or16, mkexpr(t[1]),
27211 // binop(Iop_Shr16, mkexpr(t[1]), mkU8(4))));
27212 // assign(t[3], binop(Iop_Or16, mkexpr(t[2]),
27213 // binop(Iop_Shr16, mkexpr(t[2]), mkU8(8))));
27214 // assign(t[4], unop(Iop_Not16, mkexpr(t[3])));
