Lines Matching defs:mkexpr
258 static IRExpr* mkexpr ( IRTemp tmp )
1623 NULL, mkexpr(expTmp), NULL, newVal );
1627 mkexpr(oldTmp), mkexpr(expTmp) ),
1800 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dep1))) );
1801 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(dep2))) );
1826 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dep1))) );
1864 assign( guardB, binop(Iop_CmpNE8, mkexpr(guard), mkU8(0)) );
1868 IRExpr_ITE( mkexpr(guardB),
1872 IRExpr_ITE( mkexpr(guardB),
1873 widenUto64(mkexpr(res)),
1876 IRExpr_ITE( mkexpr(guardB),
1877 widenUto64(mkexpr(resUS)),
1902 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(res))) );
1929 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(arg1)) ));
1930 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(arg2)) ));
2027 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
2030 binop(plus,mkexpr(ta1),mkexpr(ta2)),
2031 mkexpr(oldcn)) );
2038 storeLE( mkexpr(taddr), mkexpr(tres) );
2042 casLE( mkexpr(taddr),
2043 mkexpr(texpVal), mkexpr(tres), restart_point );
2048 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(ta1)) ));
2049 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(binop(xor, mkexpr(ta2),
2050 mkexpr(oldcn)) )) );
2051 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
2086 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
2089 binop(minus,mkexpr(ta1),mkexpr(ta2)),
2090 mkexpr(oldcn)) );
2097 storeLE( mkexpr(taddr), mkexpr(tres) );
2101 casLE( mkexpr(taddr),
2102 mkexpr(texpVal), mkexpr(tres), restart_point );
2107 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(ta1) )) );
2108 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(binop(xor, mkexpr(ta2),
2109 mkexpr(oldcn)) )) );
2110 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
2247 stmt( IRStmt_Put( OFFB_RIP, mkexpr(t) ) );
2301 binop(Iop_Sub64, mkexpr(new_rsp), mkU64(szB)),
2303 mkexpr(nia)
2407 //.. mkIRExprVec_4( mkexpr(ldt_ptr), mkexpr(gdt_ptr),
2408 //.. mkexpr(seg_selector), virtual)
2418 //.. binop(Iop_CmpNE32, unop(Iop_64HIto32, mkexpr(r64)), mkU32(0)),
2425 //.. return unop(Iop_64to32, mkexpr(r64));
2958 putIRegG(size, pfx, rm, mkexpr(dst1));
2963 putIRegG(size, pfx, rm, mkexpr(dst1));
2965 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2971 putIRegG(size, pfx, rm, mkexpr(dst1));
2982 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
2987 putIRegG(size, pfx, rm, mkexpr(dst1));
2992 putIRegG(size, pfx, rm, mkexpr(dst1));
2994 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3000 putIRegG(size, pfx, rm, mkexpr(dst1));
3072 putIRegE(size, pfx, rm, mkexpr(dst1));
3077 putIRegE(size, pfx, rm, mkexpr(dst1));
3079 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3085 putIRegE(size, pfx, rm, mkexpr(dst1));
3097 assign(dst0, loadLE(ty,mkexpr(addr)));
3122 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3126 casLE( mkexpr(addr),
3127 mkexpr(dst0)/*expval*/,
3128 mkexpr(dst1)/*newval*/, guest_RIP_curr_instr );
3131 storeLE(mkexpr(addr), mkexpr(dst1));
3184 putIRegG(size, pfx, rm, loadLE(szToITy(size), mkexpr(addr)));
3237 storeLE( mkexpr(addr), getIRegG(size, pfx, rm) );
3265 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3271 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3288 putIRegRAX(size, mkexpr(dst1));
3324 loadLE(szToITy(szs),mkexpr(addr))));
3349 assign( dst128, binop(op, mkexpr(src128), mkexpr(t)) );
3350 putIReg64( R_RAX, unop(Iop_128to64,mkexpr(dst128)) );
3351 putIReg64( R_RDX, unop(Iop_128HIto64,mkexpr(dst128)) );
3362 binop(op, mkexpr(src64), mkexpr(t)) );
3363 putIRegRAX( 4, unop(Iop_64to32,mkexpr(dst64)) );
3364 putIRegRDX( 4, unop(Iop_64HIto32,mkexpr(dst64)) );
3373 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
3374 putIRegRAX( 2, unop(Iop_32to16,unop(Iop_64to32,mkexpr(dst64))) );
3375 putIRegRDX( 2, unop(Iop_32to16,unop(Iop_64HIto32,mkexpr(dst64))) );
3385 binop(op, mkexpr(src64),
3386 unop(widen1632, unop(widen816, mkexpr(t)))) );
3389 unop(Iop_64to32,mkexpr(dst64)))) );
3392 unop(Iop_64HIto32,mkexpr(dst64)))) );
3441 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3449 putIRegE(sz, pfx, modrm, mkexpr(dst1));
3458 assign(dst0, loadLE(ty,mkexpr(addr)));
3483 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3486 casLE( mkexpr(addr), mkexpr(dst0)/*expVal*/,
3487 mkexpr(dst1)/*newVal*/,
3490 storeLE(mkexpr(addr), mkexpr(dst1));
3537 assign(dst0, loadLE(ty,mkexpr(addr)));
3575 = mkIRExprVec_4( widenUto64(mkexpr(dst0)), /* thing to rotate */
3577 mkexpr(old_rflags),
3590 = mkIRExprVec_4( widenUto64(mkexpr(dst0)), /* thing to rotate */
3592 mkexpr(old_rflags),
3604 assign( dst1, narrowTo(ty, mkexpr(new_value)) );
3606 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(new_rflags) ));
3647 assign( pre64, op64==Iop_Sar64 ? widenSto64(mkexpr(dst0))
3648 : widenUto64(mkexpr(dst0)) );
3651 assign( res64, binop(op64, mkexpr(pre64), mkexpr(shift_amt)) );
3656 mkexpr(pre64),
3659 mkexpr(shift_amt), mkU8(1)),
3666 assign( dst1, narrowTo(ty, mkexpr(res64)) );
3687 assign(rot_amt, mkexpr(rot_amt64));
3689 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt64), mkU8(8*sz-1)));
3697 mkexpr(dst0),
3698 mkexpr(rot_amt)
3701 mkexpr(dst0),
3702 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
3714 mkexpr(dst0),
3715 mkexpr(rot_amt)
3718 mkexpr(dst0),
3719 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
3735 assign(rot_amt64b, binop(Iop_CmpNE8, mkexpr(rot_amt64), mkU8(0)) );
3739 IRExpr_ITE( mkexpr(rot_amt64b),
3743 IRExpr_ITE( mkexpr(rot_amt64b),
3744 widenUto64(mkexpr(dst1)),
3747 IRExpr_ITE( mkexpr(rot_amt64b),
3751 IRExpr_ITE( mkexpr(rot_amt64b),
3752 mkexpr(oldFlags),
3758 putIRegE(sz, pfx, modrm, mkexpr(dst1));
3769 storeLE(mkexpr(addr), mkexpr(dst1));
3859 assign( t2, widenUto64(loadLE(ty, mkexpr(t_addr))) );
3870 assign( t2m, binop(Iop_Or64, mkU64(mask), mkexpr(t2)) );
3873 assign( t2m, binop(Iop_And64, mkU64(mask), mkexpr(t2)) );
3876 assign( t2m, binop(Iop_Xor64, mkU64(mask), mkexpr(t2)) );
3886 putIRegE(sz, pfx, modrm, narrowTo(ty, mkexpr(t2m)));
3889 casLE( mkexpr(t_addr),
3890 narrowTo(ty, mkexpr(t2))/*expd*/,
3891 narrowTo(ty, mkexpr(t2m))/*new*/,
3894 storeLE(mkexpr(t_addr), narrowTo(ty, mkexpr(t2m)));
3906 binop(Iop_Shr64, mkexpr(t2), mkU8(src_val)),
3937 assign( res128, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3938 assign( resHi, unop(Iop_128HIto64,mkexpr(res128)));
3939 assign( resLo, unop(Iop_128to64,mkexpr(res128)));
3940 putIReg64(R_RDX, mkexpr(resHi));
3941 putIReg64(R_RAX, mkexpr(resLo));
3951 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3952 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
3953 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
3954 putIRegRDX(4, mkexpr(resHi));
3955 putIRegRAX(4, mkexpr(resLo));
3965 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3966 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
3967 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
3968 putIRegRDX(2, mkexpr(resHi));
3969 putIRegRAX(2, mkexpr(resLo));
3979 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3980 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
3981 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
3982 putIRegRAX(2, mkexpr(res16));
4045 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
4046 mkexpr(src)));
4048 putIRegE(sz, pfx, modrm, mkexpr(dst1));
4101 assign(t1, loadLE(ty,mkexpr(addr)));
4108 mkexpr(t1),
4119 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
4121 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
4124 storeLE( mkexpr(addr), mkexpr(dst1) );
4133 assign(src, mkexpr(t1));
4134 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
4135 mkexpr(src)));
4137 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
4140 storeLE( mkexpr(addr), mkexpr(dst1) );
4193 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4194 putIRegE(1, pfx, modrm, mkexpr(t2));
4198 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4199 putIRegE(1, pfx, modrm, mkexpr(t2));
4219 assign( t1, loadLE(ty, mkexpr(addr)) );
4222 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4224 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
4227 storeLE( mkexpr(addr), mkexpr(t2) );
4232 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4234 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
4237 storeLE( mkexpr(addr), mkexpr(t2) );
4287 mkexpr(t1), mkU(ty,1)));
4289 putIRegE(sz,pfx,modrm, mkexpr(t2));
4294 mkexpr(t1), mkU(ty,1)));
4296 putIRegE(sz,pfx,modrm, mkexpr(t2));
4307 putIReg64(R_RSP, mkexpr(t2));
4308 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta+1));
4334 putIReg64(R_RSP, mkexpr(t2) );
4335 storeLE( mkexpr(t2), mkexpr(t3) );
4364 assign(t1, loadLE(ty,mkexpr(addr)));
4370 mkexpr(t1), mkU(ty,1)));
4372 casLE( mkexpr(addr),
4373 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
4375 storeLE(mkexpr(addr),mkexpr(t2));
4382 mkexpr(t1), mkU(ty,1)));
4384 casLE( mkexpr(addr),
4385 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
4387 storeLE(mkexpr(addr),mkexpr(t2));
4397 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4400 putIReg64(R_RSP, mkexpr(t2));
4401 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta+len));
4413 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4424 assign(t3, loadLE(ty,mkexpr(addr)));
4427 putIReg64(R_RSP, mkexpr(t2) );
4428 storeLE( mkexpr(t2), mkexpr(t3) );
4498 storeLE( mkexpr(td), loadLE(ty,mkexpr(ts)) );
4500 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4501 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4522 putIRegRAX ( sz, loadLE(ty, mkexpr(ts)) );
4524 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4545 storeLE( mkexpr(td), mkexpr(ta) );
4547 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4571 assign( tdv, loadLE(ty,mkexpr(td)) );
4573 assign( tsv, loadLE(ty,mkexpr(ts)) );
4577 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4578 incs = binop(Iop_Add64, mkexpr(ts), mkexpr(t_inc));
4603 assign( tdv, loadLE(ty,mkexpr(td)) );
4607 incd = binop(Iop_Add64, mkexpr(td), mkexpr(t_inc));
4635 cmp = binop(Iop_CmpEQ32, mkexpr(tc), mkU32(0));
4639 cmp = binop(Iop_CmpEQ64, mkexpr(tc), mkU64(0));
4646 putIReg32(R_RCX, binop(Iop_Sub32, mkexpr(tc), mkU32(1)) );
4648 putIReg64(R_RCX, binop(Iop_Sub64, mkexpr(tc), mkU64(1)) );
4692 assign( te, loadLE(ty,mkexpr(addr)) );
4697 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
4699 putIRegG(size, pfx, rm, mkexpr(resLo) );
4740 assign(te, loadLE(ty, mkexpr(addr)));
4749 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
4753 putIRegG(size, pfx, rm, mkexpr(resLo));
4787 mkexpr(old),
4788 mkexpr(mask[i])),
4790 binop(Iop_Shr16, mkexpr(old), mkU8(shift[i])),
4791 mkexpr(mask[i]))));
4815 mkexpr(old),
4816 mkexpr(mask[i])),
4818 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
4819 mkexpr(mask[i]))));
4844 mkexpr(old),
4845 mkexpr(mask[i])),
4847 binop(Iop_Shr64, mkexpr(old), mkU8(shift[i])),
4848 mkexpr(mask[i]))));
4868 assign(src64, widenUto64( mkexpr(src) ));
4872 binop(Iop_Shl64, mkexpr(src64),
4880 binop(Iop_CmpEQ64, mkexpr(src64x), mkU64(0)),
4882 unop(Iop_Clz64, mkexpr(src64x))
4886 assign(res, narrowTo(ty, mkexpr(res64)));
4901 assign(src64, widenUto64( mkexpr(src) ));
4908 binop(Iop_CmpEQ64, mkexpr(src64), mkU64(0)),
4910 unop(Iop_Ctz64, mkexpr(src64))
4914 assign(res, narrowTo(ty, mkexpr(res64)));
5099 IRExpr_ITE(mkexpr(cond), mkU8(1)/*FULL*/, mkexpr(old_tag)));
5105 IRExpr_ITE(mkexpr(cond),
5106 IRExpr_ITE(binop(Iop_CmpNE8, mkexpr(old_tag), mkU8(0)),
5111 mkexpr(old_val)));
5113 put_ST_UNCHECKED(i, mkexpr(new_val));
5116 put_ST_TAG(i, mkexpr(new_tag));
5131 put_ftop( binop(Iop_Sub32, get_ftop(), unop(Iop_1Uto32,mkexpr(cond))) );
5176 assign(i64, unop(Iop_ReinterpF64asI64, mkexpr(d64)) );
5180 binop(Iop_Shr32, unop(Iop_64HIto32, mkexpr(i64)), mkU8(20)),
5184 binop(Iop_CmpLE32U, mkexpr(exponent), mkU32(0x43D)));
5269 loadLE(Ity_F64,mkexpr(addr))
5276 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr)))
5294 loadLE(Ity_F64,mkexpr(addr)),
5301 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr))),
5381 binop(Iop_Add32, mkexpr(t32), mkU32(32768))),
5383 unop(Iop_32to16, mkexpr(t32)),
5434 loadLE(Ity_F32,mkexpr(addr)))),
5452 loadLE(Ity_F32,mkexpr(addr)))),
5562 loadLE(Ity_F32, mkexpr(addr))));
5567 storeLE(mkexpr(addr),
5573 storeLE(mkexpr(addr),
5587 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
5592 d->mAddr = mkexpr(addr);
5621 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
5622 put_emwarn( mkexpr(ew) );
5625 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
5655 loadLE(Ity_I16, mkexpr(addr)))
5660 put_fpround( unop(Iop_64to32, mkexpr(t64)) );
5661 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
5662 put_emwarn( mkexpr(ew) );
5668 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
5684 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
5688 d->mAddr = mkexpr(addr);
5724 mkexpr(addr),
5752 put_ST(0, mkexpr(t1));
5762 put_ST_UNCHECKED(0, mkexpr(t2));
5763 put_ST_UNCHECKED(r_src, mkexpr(t1));
5871 mkexpr(argOK),
5874 mkexpr(argD)),
5875 mkexpr(argD))
5877 put_ST_UNCHECKED(0, mkexpr(resD));
5884 unop(Iop_1Uto64, mkexpr(argOK)),
5908 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
5914 mkIRExprVec_2( mkexpr(argI),
5922 mkIRExprVec_2( mkexpr(argI),
5925 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
5926 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
5928 put_ST_UNCHECKED(0, mkexpr(expF) );
5931 put_ST(0, mkexpr(sigF) );
5946 mkexpr(a1),
5947 mkexpr(a2)));
5952 mkexpr(a1),
5953 mkexpr(a2)) ));
5973 mkexpr(a1),
5974 mkexpr(a2)));
5979 mkexpr(a1),
5980 mkexpr(a2)) ));
6010 mkexpr(argOK),
6013 mkexpr(argD)),
6014 mkexpr(argD))
6016 put_ST_UNCHECKED(0, mkexpr(resD));
6023 mkexpr(argD)));
6025 unop(Iop_1Uto64, mkexpr(argOK)),
6055 mkexpr(argOK),
6058 mkexpr(argD)),
6059 mkexpr(argD))
6061 put_ST_UNCHECKED(0, mkexpr(resD));
6063 unop(Iop_1Uto64, mkexpr(argOK)),
6123 loadLE(Ity_I32, mkexpr(addr)))));
6131 loadLE(Ity_I32, mkexpr(addr))),
6221 loadLE(Ity_I32, mkexpr(addr))));
6226 storeLE( mkexpr(addr),
6233 storeLE( mkexpr(addr),
6239 storeLE( mkexpr(addr),
6250 IRExpr** args = mkIRExprVec_1 ( mkexpr(addr) );
6261 d->mAddr = mkexpr(addr);
6267 put_ST(0, unop(Iop_ReinterpI64asF64, mkexpr(val)));
6278 = mkIRExprVec_2( mkexpr(addr),
6289 d->mAddr = mkexpr(addr);
6412 //.. loadLE(Ity_F64,mkexpr(addr))),
6427 loadLE(Ity_F64,mkexpr(addr))),
6509 put_ST(0, loadLE(Ity_F64, mkexpr(addr)));
6514 storeLE( mkexpr(addr),
6521 storeLE(mkexpr(addr), get_ST(0));
6526 storeLE(mkexpr(addr), get_ST(0));
6542 mkIRExprVec_1( mkexpr(addr) )
6553 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
6561 d->mAddr = mkexpr(addr);
6594 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
6595 put_emwarn( mkexpr(ew) );
6598 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
6623 mkIRExprVec_1( mkexpr(addr) )
6634 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
6641 d->mAddr = mkexpr(addr);
6681 storeLE( mkexpr(addr), sw );
6807 loadLE(Ity_I16, mkexpr(addr))))));
6816 loadLE(Ity_I16, mkexpr(addr)))),
6896 loadLE(Ity_I16, mkexpr(addr)))));
6901 storeLE( mkexpr(addr),
6909 storeLE( mkexpr(addr),
6916 storeLE( mkexpr(addr),
6927 loadLE(Ity_I64, mkexpr(addr))));
6932 storeLE( mkexpr(addr),
7172 argE = loadLE(Ity_I64, mkexpr(addr));
7199 putMMXReg( gregLO3ofRM(modrm), mkexpr(res) );
7235 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
7242 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
7262 binop(Iop_CmpLT64U,mkexpr(amt),mkU64(size)),
7263 binop(op, mkexpr(g0), mkexpr(amt8)),
7272 binop(Iop_CmpLT64U,mkexpr(amt),mkU64(size)),
7273 binop(op, mkexpr(g0), mkexpr(amt8)),
7274 binop(op, mkexpr(g0), mkU8(size-1))
7281 putMMXReg( gregLO3ofRM(rm), mkexpr(g1) );
7325 : binop(op, mkexpr(e0), mkU8(amt))
7330 ? binop(op, mkexpr(e0), mkU8(size-1))
7331 : binop(op, mkexpr(e0), mkU8(amt))
7337 putMMXReg( eregLO3ofRM(rm), mkexpr(e1) );
7380 loadLE(Ity_I32, mkexpr(addr)) ) );
7399 loadLE(Ity_I64, mkexpr(addr)) );
7422 storeLE( mkexpr(addr),
7441 storeLE( mkexpr(addr),
7465 putMMXReg( gregLO3ofRM(modrm), loadLE(Ity_I64, mkexpr(addr)) );
7486 storeLE( mkexpr(addr), getMMXReg(gregLO3ofRM(modrm)) );
7705 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
7706 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
7710 mkexpr(regD),
7711 mkexpr(mask) ),
7713 mkexpr(olddata),
7714 unop(Iop_Not64, mkexpr(mask)))) );
7715 storeLE( mkexpr(addr), mkexpr(newdata) );
7749 binop(Iop_CmpNE8, mkexpr(amt), mkU8(0)),
7751 binop(Iop_Shl64, mkexpr(base), mkexpr(amt)),
7752 binop(Iop_Shr64, mkexpr(xtra),
7753 binop(Iop_Sub8, mkU8(64), mkexpr(amt)))
7755 mkexpr(base)
7770 binop(Iop_CmpNE8, mkexpr(amt), mkU8(0)),
7772 binop(Iop_Shr64, mkexpr(base), mkexpr(amt)),
7773 binop(Iop_Shl64, mkexpr(xtra),
7774 binop(Iop_Sub8, mkU8(64), mkexpr(amt)))
7776 mkexpr(base)
7840 assign( esrc, loadLE(ty, mkexpr(addr)) );
7853 binop(Iop_Sub8, mkexpr(tmpSH), mkU8(1) ),
7865 assign( tmp64, binop(Iop_32HLto64, mkexpr(esrc), mkexpr(gsrc)) );
7868 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSH)),
7872 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSS)),
7877 assign( tmp64, binop(Iop_32HLto64, mkexpr(gsrc), mkexpr(esrc)) );
7878 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7879 assign( rss64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSS)) );
7885 binop(Iop_16HLto32, mkexpr(esrc), mkexpr(gsrc)),
7886 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(gsrc))
7891 binop(Iop_Shl64, mkexpr(tmp64), mkexpr(tmpSH)),
7897 binop(Iop_Shl64, unop(Iop_16Uto64, mkexpr(esrc)),
7899 mkexpr(tmpSS)),
7906 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(gsrc)),
7907 binop(Iop_16HLto32, mkexpr(gsrc), mkexpr(esrc))
7910 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7913 unop(Iop_16Uto64, mkexpr(esrc)),
7914 mkexpr(tmpSS)) );
7932 assign( resTy, narrowTo(ty, mkexpr(res64)) );
7933 assign( rssTy, narrowTo(ty, mkexpr(rss64)) );
7940 putIRegE(sz, pfx, modrm, mkexpr(resTy));
7942 storeLE( mkexpr(addr), mkexpr(resTy) );
8033 putIReg64(R_RSP, mkexpr(t_rsp));
8035 storeLE( mkexpr(t_rsp), getIRegE(sz, pfx, modrm) );
8038 assign( t_addr0, mkexpr(t_rsp) );
8043 mkexpr(t_bitno0),
8049 assign( t_bitno1, mkexpr(t_bitno0) );
8060 mkexpr(t_addr0),
8061 binop(Iop_Sar64, mkexpr(t_bitno1), mkU8(3))) );
8067 binop(Iop_And64, mkexpr(t_bitno1), mkU64(7))) );
8073 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
8078 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
8084 binop(Iop_Or8, mkexpr(t_fetched), mkexpr(t_mask)) );
8088 binop(Iop_Xor8, mkexpr(t_fetched), mkexpr(t_mask)) );
8092 binop(Iop_And8, mkexpr(t_fetched),
8093 unop(Iop_Not8, mkexpr(t_mask))) );
8099 casLE( mkexpr(t_addr1), mkexpr(t_fetched)/*expd*/,
8100 mkexpr(t_new)/*new*/,
8103 storeLE( mkexpr(t_addr1), mkexpr(t_new) );
8115 unop(Iop_8Uto64, mkexpr(t_fetched)),
8116 mkexpr(t_bitno2)),
8130 putIRegE(sz, pfx, modrm, loadLE(szToITy(sz), mkexpr(t_rsp)) );
8131 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t_rsp), mkU64(288)) );
8170 assign( src, loadLE(ty, mkexpr(addr)) );
8179 assign( src64, widenUto64(mkexpr(src)) );
8187 assign( srcB, binop(Iop_ExpCmpNE64, mkexpr(src64), mkU64(0)) );
8195 IRExpr_ITE( mkexpr(srcB),
8235 mkexpr(srcB),
8237 fwds ? unop(Iop_Ctz64, mkexpr(src64))
8240 unop(Iop_Clz64, mkexpr(src64))),
8247 assign( dst, unop(Iop_64to16, mkexpr(dst64)) );
8250 assign( dst, unop(Iop_64to32, mkexpr(dst64)) );
8252 assign( dst, mkexpr(dst64) );
8255 putIRegG( sz, pfx, modrm, mkexpr(dst) );
8273 putIReg64( R_RAX, mkexpr(t2) );
8274 putIRegRexB(8, pfx, regLo3, mkexpr(t1) );
8278 putIReg32( R_RAX, mkexpr(t2) );
8279 putIRegRexB(4, pfx, regLo3, mkexpr(t1) );
8283 putIReg16( R_RAX, mkexpr(t2) );
8284 mkexpr(t1) );
8310 binop(Iop_And64, mkexpr(oldflags), mkU64(AMD64G_CC_MASK_O)),
8335 = binop(Iop_Or64, binop(Iop_And64, mkexpr(flags), mkU64(mask_SZACP)),
8400 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
8401 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8402 putIRegRAX(size, mkexpr(acc2));
8403 putIRegE(size, pfx, rm, mkexpr(dest2));
8411 assign( dest, loadLE(ty, mkexpr(addr)) );
8417 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
8418 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8419 putIRegRAX(size, mkexpr(acc2));
8420 storeLE( mkexpr(addr), mkexpr(dest2) );
8435 mkIRCAS( IRTemp_INVALID, dest, Iend_LE, mkexpr(addr),
8436 NULL, mkexpr(acc), NULL, mkexpr(src) )
8440 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8441 putIRegRAX(size, mkexpr(acc2));
8490 mkexpr(tmps),
8491 mkexpr(tmpd) )
8502 assign( tmps, loadLE(ty, mkexpr(addr)) );
8507 mkexpr(tmps),
8508 mkexpr(tmpd) )
8549 mkexpr(tmpd), mkexpr(tmpt0)) );
8551 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8552 putIRegE(sz, pfx, rm, mkexpr(tmpt1));
8561 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8564 mkexpr(tmpd), mkexpr(tmpt0)) );
8566 storeLE( mkexpr(addr), mkexpr(tmpt1) );
8567 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8576 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8579 mkexpr(tmpd), mkexpr(tmpt0)) );
8580 casLE( mkexpr(addr), mkexpr(tmpd)/*expVal*/,
8581 mkexpr(tmpt1)/*newVal*/, guest_RIP_curr_instr );
8583 putIRegG(sz, pfx, rm, mkexpr(tmpd));
8609 //.. putSReg( gregOfRM(rm), loadLE(Ity_I16, mkexpr(addr)) );
8640 //.. storeLE( mkexpr(addr), getSReg(gregOfRM(rm)) );
8689 storeLE(mkexpr(addr), mkU16(0));
8705 //.. putIReg(4, R_ESP, mkexpr(ta));
8706 //.. storeLE( mkexpr(ta), mkexpr(t1) );
8719 //.. assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
8721 //.. putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(ta), mkU32(sz)) );
8722 //.. putSReg( sreg, mkexpr(t1) );
8733 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
8734 assign(t3, binop(Iop_Add64, mkexpr(t1), mkU64(8+d64)));
8735 putIReg64(R_RSP, mkexpr(t3));
8812 loadLE(Ity_V128, mkexpr(addr)))
8814 loadLE(Ity_V128, mkexpr(addr)))
8870 loadLE(Ity_I32, mkexpr(addr))) );
8872 binop(op, gpart, mkexpr(epart)) );
8906 loadLE(Ity_I64, mkexpr(addr))) );
8908 binop(op, gpart, mkexpr(epart)) );
8944 IRExpr* src = loadLE(Ity_V128, mkexpr(addr));
8979 mkexpr(oldG0),
8981 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
8990 mkexpr(oldG0),
8991 loadLE(Ity_I32, mkexpr(addr)) ));
8992 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
9023 mkexpr(oldG0),
9025 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
9034 mkexpr(oldG0),
9035 loadLE(Ity_I64, mkexpr(addr)) ));
9036 putXMMReg( gregOfRexRM(pfx,rm), unop(op, mkexpr(oldG1)) );
9070 epart = loadLE(Ity_V128, mkexpr(addr));
9259 ? loadLE(Ity_V128, mkexpr(addr))
9261 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
9263 unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr)))
9275 unop(Iop_NotV128, mkexpr(plain)) );
9281 binop(Iop_XorV128, mkexpr(plain), mkV128(mask)) );
9284 putXMMReg( gregOfRexRM(pfx,rm), mkexpr(plain) );
9315 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
9322 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
9342 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
9343 binop(op, mkexpr(g0), mkexpr(amt8)),
9352 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
9353 binop(op, mkexpr(g0), mkexpr(amt8)),
9354 binop(op, mkexpr(g0), mkU8(size-1))
9361 putXMMReg( gregOfRexRM(pfx,rm), mkexpr(g1) );
9404 : binop(op, mkexpr(e0), mkU8(amt))
9409 ? binop(op, mkexpr(e0), mkU8(size-1))
9410 : binop(op, mkexpr(e0), mkU8(amt))
9416 putXMMReg( eregOfRexRM(pfx,rm), mkexpr(e1) );
9448 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
9449 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
9460 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
9461 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
9462 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
9463 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
9473 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
9474 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
9487 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
9488 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
9499 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
9500 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
9501 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
9502 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
9512 binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)),
9513 binop(Iop_16HLto32, mkexpr(t1), mkexpr(t0))
9532 assign( *t0, unop(Iop_V256to64_0, mkexpr(t256)) );
9533 assign( *t1, unop(Iop_V256to64_1, mkexpr(t256)) );
9534 assign( *t2, unop(Iop_V256to64_2, mkexpr(t256)) );
9535 assign( *t3, unop(Iop_V256to64_3, mkexpr(t256)) );
9548 assign(*t1, unop(Iop_V256toV128_1, mkexpr(t256)));
9549 assign(*t0, unop(Iop_V256toV128_0, mkexpr(t256)));
9578 assign( *t0, unop(Iop_V128to64, mkexpr(t128)) );
9579 assign( *t1, unop(Iop_V128HIto64, mkexpr(t128)) );
9592 binop(Iop_32HLto64, mkexpr(t7), mkexpr(t6)),
9593 binop(Iop_32HLto64, mkexpr(t5), mkexpr(t4)) ),
9595 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
9596 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0)) )
9607 binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)),
9608 binop(Iop_64HLtoV128, mkexpr(t1), mkexpr(t0))
9632 binop(Iop_InterleaveHI16x4, mkexpr(aa), mkexpr(aa)),
9636 binop(Iop_InterleaveLO16x4, mkexpr(aa), mkexpr(aa)),
9640 binop(Iop_InterleaveHI16x4, mkexpr(bb), mkexpr(bb)),
9644 binop(Iop_InterleaveLO16x4, mkexpr(bb), mkexpr(bb)),
9655 binop(Iop_Mul32x2, mkexpr(aahi32s), mkexpr(bbhi32s)),
9658 mkexpr(one32x2)
9671 binop(Iop_Mul32x2, mkexpr(aalo32s), mkexpr(bblo32s)),
9674 mkexpr(one32x2)
9680 binop(Iop_CatEvenLanes16x4, mkexpr(rHi), mkexpr(rLo));
9711 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
9712 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
9713 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
9717 binop(Iop_And64, mkexpr(bb), mkexpr(posMask)),
9718 binop(Iop_And64, mkexpr(bbNeg), mkexpr(negMask)) );
9749 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
9750 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
9752 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
9755 binop(Iop_And64, mkexpr(aa), mkexpr(posMask)),
9756 binop(Iop_And64, mkexpr(aaNeg), mkexpr(negMask)) ));
9766 mkexpr(aa)));
9767 assign(aaLo, unop(Iop_V128to64, mkexpr(aa)));
9769 mkexpr(math_PABS_MMX(aaHi, laneszB)),
9770 mkexpr(math_PABS_MMX(aaLo, laneszB))));
9796 mkexpr(math_PABS_XMM(aaHi, laneszB)),
9797 mkexpr(math_PABS_XMM(aaLo, laneszB))));
9819 binop(Iop_Shl64, mkexpr(hi64), mkU8(8*(8-byteShift))),
9820 binop(Iop_Shr64, mkexpr(lo64), mkU8(8*byteShift))
9834 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
9835 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
9836 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
9837 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
9840 assign( rHi, mkexpr(sHi) );
9841 assign( rLo, mkexpr(sLo) );
9848 assign( rHi, mkexpr(dLo) );
9849 assign( rLo, mkexpr(sHi) );
9856 assign( rHi, mkexpr(dHi) );
9857 assign( rLo, mkexpr(dLo) );
9860 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-16))) );
9865 assign( rLo, mkexpr(dHi) );
9869 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-24))) );
9878 assign( res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
9893 binop(Iop_And64,mkexpr(effective_addr),mkU64(mask)),
10070 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
10086 binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)) ),
10113 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
10130 unop(Iop_F32toF64,mkexpr(argL)),
10131 unop(Iop_F32toF64,mkexpr(argR)))),
10158 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10179 (gregOfRexRM(pfx,modrm), mkexpr(dV));
10202 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
10239 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
10240 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
10243 assign( lo64r, mkexpr(lo64) );
10244 assign( hi64r, mkexpr(hi64) );
10249 assign( lo64r, mkexpr(hi64) );
10254 assign( lo64r, binop( Iop_Shr64, mkexpr(hi64), mkU8( 8*(imm-8) ) ));
10256 assign( hi64r, binop( Iop_Shr64, mkexpr(hi64), mkU8(8 * imm) ));
10259 binop(Iop_Shr64, mkexpr(lo64),
10261 binop(Iop_Shl64, mkexpr(hi64),
10267 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
10286 mkexpr(sV)) );
10287 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
10290 assign( lo64r, mkexpr(lo64) );
10291 assign( hi64r, mkexpr(hi64) );
10296 assign( hi64r, mkexpr(lo64) );
10301 assign( hi64r, binop( Iop_Shl64, mkexpr(lo64), mkU8( 8*(imm-8) ) ));
10303 assign( lo64r, binop( Iop_Shl64, mkexpr(lo64), mkU8(8 * imm) ));
10306 binop(Iop_Shl64, mkexpr(hi64),
10308 binop(Iop_Shr64, mkexpr(lo64),
10314 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
10340 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
10356 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo)) );
10360 binop( Iop_F64toI64S, mkexpr(rmode), mkexpr(f64lo)) );
10388 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
10405 mkexpr(rmode),
10406 unop(Iop_F32toF64, mkexpr(f32lo))) );
10411 mkexpr(rmode),
10412 unop(Iop_F32toF64, mkexpr(f32lo))) );
10438 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
10440 binop(Iop_Add64,mkexpr(addr),mkU64(4))) );
10446 putXMMRegLane64F( rG, 1, unop(Iop_F32toF64, mkexpr(f32hi)) );
10447 putXMMRegLane64F( rG, 0, unop(Iop_F32toF64, mkexpr(f32lo)) );
10476 assign( f32_0, loadLE(Ity_F32, mkexpr(addr)) );
10478 binop(Iop_Add64,mkexpr(addr),mkU64(4))) );
10480 binop(Iop_Add64,mkexpr(addr),mkU64(8))) );
10482 binop(Iop_Add64,mkexpr(addr),mkU64(12))) );
10487 putYMMRegLane64F( rG, 3, unop(Iop_F32toF64, mkexpr(f32_3)) );
10488 putYMMRegLane64F( rG, 2, unop(Iop_F32toF64, mkexpr(f32_2)) );
10489 putYMMRegLane64F( rG, 1, unop(Iop_F32toF64, mkexpr(f32_1)) );
10490 putYMMRegLane64F( rG, 0, unop(Iop_F32toF64, mkexpr(f32_0)) );
10513 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10523 unop(Iop_V128to64, mkexpr(argV))) );
10525 unop(Iop_V128HIto64, mkexpr(argV))) );
10527 # define CVT(_t) binop( Iop_F64toF32, mkexpr(rmode), mkexpr(_t) )
10560 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10574 mkexpr(rmode), \
10576 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10610 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10624 mkexpr(rmode), \
10626 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10662 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10677 unop(Iop_V128to64, mkexpr(argV))) );
10679 unop(Iop_V128HIto64, mkexpr(argV))) );
10682 mkexpr(rmode), \
10683 mkexpr(_t) )
10717 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10736 mkexpr(rmode), \
10738 mkexpr(_t) ) )
10771 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10785 mkexpr
10786 unop(Iop_I32StoF64,mkexpr(_t)))
10818 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10835 mkexpr(rmode), \
10836 unop(Iop_I32StoF64,mkexpr(_t)))
10862 assign(t1, unop(Iop_16Uto32, unop(Iop_GetMSBs8x16, mkexpr(t0))));
10863 putIReg32(rG, mkexpr(t1));
10884 assign(t2, unop(Iop_GetMSBs8x16, mkexpr(t0)));
10885 assign(t3, unop(Iop_GetMSBs8x16, mkexpr(t1)));
10886 putIReg32(rG, binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)));
10917 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10918 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10919 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10920 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10922 assign(res, xIsH ? binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1))
10923 : binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)));
10940 ? IRExpr_Qop(Iop_64x4toV256, mkexpr(s3), mkexpr(d3),
10941 mkexpr(s1), mkexpr(d1))
10942 : IRExpr_Qop(Iop_64x4toV256, mkexpr(s2), mkexpr(d2),
10943 mkexpr(s0), mkexpr(d0)));
10963 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11001 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11013 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
11014 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
11015 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
11016 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
11018 # define SELD(n) mkexpr((n)==0 ? d0 : d1)
11019 # define SELS(n) mkexpr((n)==0 ? s0 : s1)
11040 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11061 binop( Iop_AndV128, mkexpr(sV),
11062 mkexpr(imm8_mask) ),
11063 binop( Iop_AndV128, mkexpr(dV),
11064 unop( Iop_NotV128, mkexpr(imm8_mask) ) ) ) );
11078 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11094 binop( Iop_AndV128, mkexpr(sV),
11095 mkexpr(imm8_mask) ),
11096 binop( Iop_AndV128, mkexpr(dV),
11097 unop( Iop_NotV128, mkexpr(imm8_mask) ) ) ) );
11111 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11131 binop( Iop_AndV128, mkexpr(sV),
11132 mkexpr(imm16_mask) ),
11133 binop( Iop_AndV128, mkexpr(dV),
11134 unop( Iop_NotV128, mkexpr(imm16_mask) ) ) ) );
11149 binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)),
11150 binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) ));
11165 mkexpr(math_PMULUDQ_128(sHi, dHi)),
11166 mkexpr(math_PMULUDQ_128(sLo, dLo))));
11181 binop( Iop_MullS32, mkexpr(d2), mkexpr(s2)),
11182 binop( Iop_MullS32, mkexpr(d0), mkexpr(s0)) ));
11197 mkexpr(math_PMULDQ_128(sHi, dHi)),
11198 mkexpr(math_PMULDQ_128(sLo, dLo))));
11214 mkIRExprVec_2( mkexpr(sVhi), mkexpr(dVhi))));
11218 mkIRExprVec_2( mkexpr(sVlo), mkexpr(dVlo))));
11220 assign( res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo))) ;
11233 mkexpr(math_PMADDWD_128(dHi, sHi)),
11234 mkexpr(math_PMADDWD_128(dLo, sLo))));
11248 assign( addV, triop(Iop_Add64Fx2, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11249 assign( subV, triop(Iop_Sub64Fx2, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11251 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
11252 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
11255 assign( res, binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
11269 assign( addV, triop(Iop_Add64Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11270 assign( subV, triop(Iop_Sub64Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11290 assign( addV, triop(Iop_Add32Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11291 assign( subV, triop(Iop_Sub32Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11313 assign( addV, triop(Iop_Add32Fx8, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11314 assign( subV, triop(Iop_Sub32Fx8, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11352 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11362 assign( sVmut, unop(xIsH ? Iop_V128HIto64 : Iop_V128to64, mkexpr(sV)) );
11363 assign( sVcon, unop(xIsH ? Iop_V128to64 : Iop_V128HIto64, mkexpr(sV)) );
11372 assign(dV, xIsH ? binop(Iop_64HLtoV128, mkexpr(dVmut), mkexpr(sVcon))
11373 : binop(Iop_64HLtoV128, mkexpr(sVcon), mkexpr(dVmut)) );
11375 (isAvx ? putYMMRegLoAndZU : putXMMReg)(rG, mkexpr(dV));
11405 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
11452 case 0: assign(d16, unop(Iop_32to16, mkexpr(s0))); break;
11453 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(s0))); break;
11454 case 2: assign(d16, unop(Iop_32to16, mkexpr(s1))); break;
11455 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(s1))); break;
11456 case 4: assign(d16, unop(Iop_32to16, mkexpr(s2))); break;
11457 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(s2))); break;
11458 case 6: assign(d16, unop(Iop_32to16, mkexpr(s3))); break;
11459 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(s3))); break;
11462 putIReg32(rG, unop(Iop_16Uto32, mkexpr(d16)));
11484 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11490 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)))
11494 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)))
11521 mkexpr(addr),
11565 loadLE(Ity_I32, mkexpr(addr))
11571 put_sse_roundingmode( unop(Iop_64to32, mkexpr(t64)) );
11572 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
11573 put_emwarn( mkexpr(ew) );
11579 binop(Iop_CmpNE64, unop(Iop_32Uto64,mkexpr(ew)), mkU64(0)),
11600 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
11602 d0->guard = binop(Iop_CmpEQ64, binop(Iop_And64, mkexpr(rfbm), mkU64(1)),
11610 d0->mAddr = mkexpr(addr);
11643 assign(rfbm_1, binop(Iop_And64, mkexpr(rfbm), mkU64(2)));
11644 assign(rfbm_1or2, binop(Iop_And64, mkexpr(rfbm), mkU64(6)));
11646 IRExpr* guard_1 = binop(Iop_CmpEQ64, mkexpr(rfbm_1), mkU64(2));
11647 IRExpr* guard_1or2 = binop(Iop_CmpNE64, mkexpr(rfbm_1or2), mkU64(0));
11660 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
11669 d1->mAddr = binop(Iop_Add64, mkexpr(addr), mkU64(24));
11692 binop(Iop_Add64, mkexpr(addr), mkU64(160 + reg * 16)),
11703 assign(rfbm_2, binop(Iop_And64, mkexpr(rfbm), mkU64(4)));
11705 IRExpr* guard_2 = binop(Iop_CmpEQ64, mkexpr(rfbm_2), mkU64(4));
11710 binop(Iop_Add64, mkexpr(addr), mkU64(576 + reg * 16)),
11757 assign(addr_plus_512, binop(Iop_Add64, mkexpr(addr), mkU64(512)));
11758 storeLE( mkexpr(addr_plus_512),
11760 unop(Iop_64to8, mkexpr(rfbm)),
11761 loadLE(Ity_I8, mkexpr(addr_plus_512))) );
11810 assign(rfbm_0, binop(Iop_And64, mkexpr(rfbm), mkU64(1)));
11811 assign(xstate_bv_0, binop(Iop_And64, mkexpr(xstate_bv), mkU64(1)));
11812 assign(restore_0, binop(Iop_And64, mkexpr(rfbm_0), mkexpr(xstate_bv_0)));
11814 gen_FINIT_SEQUENCE( binop(Iop_CmpNE64, mkexpr(rfbm_0), mkU64(0)) );
11823 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
11825 d0->guard = binop(Iop_CmpNE64, mkexpr(restore_0), mkU64(0));
11832 d0->mAddr = mkexpr(addr);
11868 assign(rfbm_1, binop(Iop_And64, mkexpr(rfbm), mkU64(2)));
11869 assign(xstate_bv_1, binop(Iop_And64, mkexpr(xstate_bv), mkU64(2)));
11870 assign(restore_1, binop(Iop_And64, mkexpr(rfbm_1), mkexpr(xstate_bv_1)));
11871 IRExpr* rfbm_1e = binop(Iop_CmpNE64, mkexpr(rfbm_1), mkU64(0));
11872 IRExpr* restore_1e = binop(Iop_CmpNE64, mkexpr(restore_1), mkU64(0));
11877 assign(rfbm_1or2, binop(Iop_And64, mkexpr(rfbm), mkU64(6)));
11878 assign(xstate_bv_1or2, binop(Iop_And64, mkexpr(xstate_bv), mkU64(6)));
11879 assign(restore_1or2, binop(Iop_And64, mkexpr(rfbm_1or2),
11880 mkexpr(xstate_bv_1or2)));
11881 IRExpr* rfbm_1or2e = binop(Iop_CmpNE64, mkexpr(rfbm_1or2), mkU64(0));
11882 IRExpr* restore_1or2e = binop(Iop_CmpNE64, mkexpr(restore_1or2), mkU64(0));
11904 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
11913 d1->mAddr = binop(Iop_Add64, mkexpr(addr), mkU64(24));
11936 IRExpr* ea = binop(Iop_Add64, mkexpr(addr), mkU64(160 + reg * 16));
11942 putXMMReg(reg, mkexpr(loadedValue));
11954 assign(rfbm_2, binop(Iop_And64, mkexpr(rfbm), mkU64(4)));
11955 assign(xstate_bv_2, binop(Iop_And64, mkexpr(xstate_bv), mkU64(4)));
11956 assign(restore_2, binop(Iop_And64, mkexpr(rfbm_2), mkexpr(xstate_bv_2)));
11958 IRExpr* rfbm_2e = binop(Iop_CmpNE64, mkexpr(rfbm_2), mkU64(0));
11959 IRExpr* restore_2e = binop(Iop_CmpNE64, mkexpr(restore_2), mkU64(0));
11966 IRExpr* ea = binop(Iop_Add64, mkexpr(addr), mkU64(576 + reg * 16));
11972 putYMMRegLane128(reg, 1, mkexpr(loadedValue));
12009 binop(Iop_Add64, mkexpr(addr), mkU64(512+0))));
12013 binop(Iop_Add64, mkexpr(addr), mkU64(512+8))));
12018 binop(Iop_Add64, mkexpr(addr), mkU64(512+16))));
12031 binop(Iop_And64, mkexpr(xstate_bv), mkU64(~aSSUMED_XCR0_VALUE)),
12032 binop(Iop_Or64, mkexpr(xcomp_bv), mkexpr(xsavehdr_23_16))));
12033 stmt( IRStmt_Exit(binop(Iop_CmpNE64, mkexpr(fault_if_nonzero), mkU64(0)),
12087 unop(Iop_16Uto64, mkexpr(u16)),
12090 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
12092 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
12098 mkexpr(tmp128),
12099 binop(Iop_AndV128, mkexpr(v128), mkV128(mask))) );
12118 mkIRExprVec_2( mkexpr(s1), mkexpr(d1))),
12122 mkIRExprVec_2( mkexpr(s0), mkexpr(d0)))) );
12135 mkexpr(math_PSADBW_128(dHi, sHi)),
12136 mkexpr(math_PSADBW_128(dLo, sLo))));
12167 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
12170 mkexpr(regD),
12171 mkexpr(mask) ),
12173 mkexpr(olddata),
12174 unop(Iop_NotV128, mkexpr(mask)))) );
12175 storeLE( mkexpr(addr), mkexpr(newdata) );
12208 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
12209 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ) );
12256 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
12257 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ),
12259 binop(Iop_Or32, mkexpr(t4), mkexpr(t5)),
12260 binop(Iop_Or32, mkexpr(t6), mkexpr(t7)) ) ) );
12281 putIReg32( rG, binop(Iop_Or32, mkexpr(t0), mkexpr(t1) ) );
12311 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
12312 binop(Iop_Or32, mkexpr(t2), mkexpr(t3)) ) );
12360 loadLE(Ity_V128, mkexpr(addr)) );
12383 loadLE(Ity_I64, mkexpr(addr)) );
12405 loadLE(Ity_I32, mkexpr(addr)) );
12425 loadLE(Ity_V128, mkexpr(addr)) );
12448 storeLE( mkexpr(addr),
12464 storeLE( mkexpr(addr),
12484 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12499 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12521 loadLE(Ity_I64, mkexpr(addr)) );
12543 loadLE(Ity_I64, mkexpr(addr)) );
12559 storeLE( mkexpr(addr),
12576 storeLE( mkexpr(addr),
12607 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12613 putXMMReg( rG, mkexpr(res) );
12635 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12641 putXMMReg( rG, mkexpr(res) );
12659 loadLE(Ity_I64, mkexpr(addr)) );
12680 loadLE(Ity_I64, mkexpr(addr)) );
12696 storeLE( mkexpr(addr),
12713 storeLE( mkexpr(addr),
12769 loadLE(Ity_V128, mkexpr(addr)) );
12790 loadLE(Ity_V128, mkexpr(addr)) );
12813 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12833 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
12858 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12869 mkexpr(rmode),
12871 unop(Iop_64to32, mkexpr(arg64)) )) );
12876 mkexpr(rmode),
12878 unop(Iop_64HIto32, mkexpr(arg64)) )) );
12898 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
12906 mkexpr(rmode),
12907 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
12918 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12926 mkexpr(rmode),
12927 binop(Iop_I64StoF64, mkexpr(rmode), mkexpr(arg64)) ) );
12946 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
12952 unop(Iop_I32StoF64, mkexpr(arg32))
12964 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12974 mkexpr(arg64)
13000 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
13008 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)) )
13013 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)) )
13029 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
13065 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
13067 mkexpr(addr),
13085 mkexpr(rmode),
13086 unop( Iop_F32toF64, mkexpr(f32hi) ) ),
13088 mkexpr(rmode),
13089 unop( Iop_F32toF64, mkexpr(f32lo) ) )
13093 putMMXReg(gregLO3ofRM(modrm), mkexpr(dst64));
13151 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
13153 mkexpr(addr),
13170 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64hi) ),
13171 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo) )
13175 putMMXReg(gregLO3ofRM(modrm), mkexpr(dst64));
13417 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
13424 unop( Iop_F32toF64, mkexpr(f32lo) ) );
13442 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
13451 binop( Iop_F64toF32, mkexpr(rmode), mkexpr(f64lo) )
13748 ? unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)) )
13749 : unop( Iop_64UtoV128,loadLE(Ity_I64, mkexpr(addr)) )
13773 loadLE(Ity_V128, mkexpr(addr)) );
13792 loadLE(Ity_V128, mkexpr(addr)) );
13827 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13841 putMMXReg(gregLO3ofRM(modrm), mkexpr(dV));
13921 putXMMReg(reg, mkexpr(math_PSRLDQ( sV, imm )));
13936 putXMMReg(reg, mkexpr(math_PSLLDQ( sV, imm )));
14000 loadLE(Ity_I64, mkexpr(addr)) );
14028 storeLE( mkexpr(addr),
14053 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
14071 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
14125 mkexpr(addr),
14215 storeLE( mkexpr(addr), getIRegG(sz, pfx, modrm) );
14255 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
14268 putMMXReg(gregLO3ofRM(modrm), mkexpr(t6));
14291 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
14298 putXMMReg(rG, mkexpr(res_vec));
14316 case 0: assign(t5, mkexpr(t0)); break;
14317 case 1: assign(t5, mkexpr(t1)); break;
14318 case 2: assign(t5, mkexpr(t2)); break;
14319 case 3: assign(t5, mkexpr(t3)); break;
14323 putIReg64(gregOfRexRM(pfx,modrm), unop(Iop_16Uto64, mkexpr(t5)));
14325 putIReg32(gregOfRexRM(pfx,modrm), unop(Iop_16Uto32, mkexpr(t5)));
14369 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14375 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
14396 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14405 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
14486 storeLE( mkexpr(addr),
14532 assign(t1, unop(Iop_8Uto32, unop(Iop_GetMSBs8x8, mkexpr(t0))));
14533 putIReg32(gregOfRexRM(pfx,modrm), mkexpr(t1));
14737 storeLE( mkexpr(addr), getMMXReg(gregLO3ofRM(modrm)) );
14751 storeLE( mkexpr(addr), getXMMReg(gregOfRexRM(pfx,modrm)) );
14888 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14892 putXMMReg( rG, mkexpr(math_PMULUDQ_128( sV, dV )) );
14915 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14921 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
14922 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
14924 binop( Iop_MullU32, mkexpr(t0), mkexpr(t1) ) );
14944 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14949 putXMMReg( rG, mkexpr(math_PMADDWD_128(dV, sV)) );
14977 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14982 putXMMReg( rG, mkexpr( math_PSADBW_128 ( dV, sV ) ) );
15111 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
15114 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
15120 ( rG, binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
15143 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
15145 mkexpr(addr), mkU64(16))) );
15149 putYMMRegLane64( rG, 0, mkexpr(d0) );
15150 putYMMRegLane64( rG, 1, mkexpr(d0) );
15151 putYMMRegLane64( rG, 2, mkexpr(d1) );
15152 putYMMRegLane64( rG, 3, mkexpr(d1) );
15178 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15210 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
15241 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
15257 assign( leftV, binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
15258 assign( rightV, binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
15263 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
15331 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
15337 putXMMReg( rG, mkexpr( math_HADDPS_128 ( gV, eV, isAdd ) ) );
15356 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
15362 putXMMReg( rG, mkexpr( math_HADDPD_128 ( gV, eV, isAdd ) ) );
15381 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
15387 putXMMReg( rG, mkexpr( math_ADDSUBPD_128 ( gV, eV ) ) );
15405 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
15411 putXMMReg( rG, mkexpr( math_ADDSUBPS_128 ( gV, eV ) ) );
15425 loadLE(Ity_V128, mkexpr(addr)) );
15475 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15476 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15477 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15478 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15491 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sHi),mkU8(7))));
15496 binop(Iop_ShlN8x8,mkexpr(sHi),mkU8(4)),
15499 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
15506 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7hi)),
15507 mkexpr(maskBit3hi)),
15509 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7hi)),
15510 unop(Iop_Not64,mkexpr(maskBit3hi))) ));
15512 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
15518 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sLo),mkU8(7))));
15523 binop(Iop_ShlN8x8,mkexpr(sLo),mkU8(4)),
15526 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
15533 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7lo)),
15534 mkexpr(maskBit3lo)),
15536 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7lo)),
15537 unop(Iop_Not64,mkexpr(maskBit3lo))) ));
15539 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
15541 assign(res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
15555 mkexpr(math_PSHUFB_XMM(dHi, sHi)),
15556 mkexpr(math_PSHUFB_XMM(dLo, sLo))));
15607 mkexpr(addr)) );
15613 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15614 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15615 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15616 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15626 binop(opCatE,mkexpr(sHi),mkexpr(sLo)),
15627 binop(opCatO,mkexpr(sHi),mkexpr(sLo)) ),
15629 binop(opCatE,mkexpr(dHi),mkexpr(dLo)),
15630 binop(opCatO,mkexpr(dHi),mkexpr(dLo)) ) ) );
15676 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
15692 binop(opCatE,mkexpr(s3),mkexpr(s2)),
15693 binop(opCatO,mkexpr(s3),mkexpr(s2)) ),
15695 binop(opCatE,mkexpr(d3),mkexpr(d2)),
15696 binop(opCatO,mkexpr(d3),mkexpr(d2)) ) ),
15699 binop(opCatE,mkexpr(s1),mkexpr(s0)),
15700 binop(opCatO,mkexpr(s1),mkexpr(s0)) ),
15702 binop(opCatE,mkexpr(d1),mkexpr(d0)),
15703 binop(opCatO,mkexpr(d1),mkexpr(d0)) ) ) ) );
15715 assign( sVoddsSX, binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
15717 binop(Iop_ShlN16x8, mkexpr(sV), mkU8(8)),
15719 assign( dVoddsZX, binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
15721 binop(Iop_ShlN16x8, mkexpr(dV), mkU8(8)),
15726 binop(Iop_Mul16x8, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
15727 binop(Iop_Mul16x8, mkexpr(sVevensSX), mkexpr(dVevensZX))
15743 mkexpr(math_PMADDUBSW_128(dHi, sHi)),
15744 mkexpr(math_PMADDUBSW_128(dLo, sLo))));
15785 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15792 putXMMReg(gregOfRexRM(pfx,modrm), mkexpr(res));
15811 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15824 mkexpr(dV),
15825 binop(Iop_And64, mkexpr(sV), mkU64(0x0707070707070707ULL))
15828 unop(Iop_Not64, binop(Iop_SarN8x8, mkexpr(sV), mkU8(7)))
15905 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15914 binop(opCatE,mkexpr(sV),mkexpr(dV)),
15915 binop(opCatO,mkexpr(sV),mkexpr(dV))
15942 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15947 putXMMReg( rG, mkexpr( math_PMADDUBSW_128( dV, sV ) ) );
15971 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15979 binop(Iop_SarN16x4, mkexpr(sV), mkU8(8)) );
15982 binop(Iop_ShlN16x4, mkexpr(sV), mkU8(8)),
15985 binop(Iop_ShrN16x4, mkexpr(dV), mkU8(8)) );
15988 binop(Iop_ShlN16x4, mkexpr(dV), mkU8(8)),
15994 binop(Iop_Mul16x4, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
15995 binop(Iop_Mul16x4, mkexpr(sVevensSX), mkexpr(dVevensZX))
16037 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16043 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
16044 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
16045 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
16046 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
16051 dis_PSIGN_helper( mkexpr(sHi), mkexpr
16052 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
16084 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
16092 dis_PSIGN_helper( mkexpr(sV), mkexpr(dV), laneszB )
16121 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16127 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
16128 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
16129 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
16130 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
16135 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
16136 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
16158 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
16166 dis_PMULHRSW_helper( mkexpr(sV), mkexpr(dV) )
16200 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16207 mkexpr(math_PABS_XMM(sV, laneszB)) );
16235 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
16242 mkexpr(math_PABS_MMX( sV, laneszB )) );
16307 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
16316 putXMMReg( gregOfRexRM(pfx,modrm), mkexpr(res) );
16338 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
16347 assign( res, mkexpr(sV) );
16352 binop(Iop_Shr64, mkexpr(sV), mkU8(8*d64)),
16353 binop(Iop_Shl64, mkexpr(dV), mkU8(8*(8-d64))
16357 assign( res, mkexpr(dV) );
16360 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d64-8))) );
16368 putMMXReg( gregLO3ofRM(modrm), mkexpr(res) );
16430 assign(src, loadLE(ty, mkexpr(addr)));
16437 putIRegG(sz, pfx, modrm, mkexpr(result));
16449 widenUto64(mkexpr(src)),
16475 assign(src, loadLE(ty, mkexpr(addr)));
16482 putIRegG(sz, pfx, modrm, mkexpr(res));
16490 assign(src64, widenUto64(mkexpr(src)));
16491 assign(res64, widenUto64(mkexpr(res)));
16499 binop(Iop_CmpEQ64, mkexpr(res64), mkU64(0))),
16503 binop(Iop_CmpEQ64, mkexpr(src64), mkU64(0))),
16511 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
16536 assign(src, loadLE(ty, mkexpr(addr)));
16543 putIRegG(sz, pfx, modrm, mkexpr(res));
16551 assign(src64, widenUto64(mkexpr(src)));
16552 assign(res64, widenUto64(mkexpr(res)));
16560 binop(Iop_CmpEQ64, mkexpr(res64), mkU64(0))),
16564 binop(Iop_CmpEQ64, mkexpr(src64), mkU64(0))),
16572 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
16610 assign(mask, binop(opSAR, mkexpr(vec0), mkexpr(sh)));
16613 assign(notmask, unop(Iop_NotV128, mkexpr(mask)));
16617 binop(Iop_AndV128, mkexpr(vecE), mkexpr(mask)),
16618 binop(Iop_AndV128, mkexpr(vecG), mkexpr(notmask))));
16638 binop(opSAR128, mkexpr(vec0Hi), mkexpr(sh)),
16639 binop(opSAR128, mkexpr(vec0Lo), mkexpr(sh))));
16642 assign(notmask, unop(Iop_NotV256, mkexpr(mask)));
16646 binop(Iop_AndV256, mkexpr(vecE), mkexpr(mask)),
16647 binop(Iop_AndV256, mkexpr(vecG), mkexpr(notmask))));
16676 assign(vecE, loadLE(Ity_V128, mkexpr(addr)));
16686 putYMMRegLoAndZU( rG, mkexpr(res) );
16715 assign(vecE, loadLE(Ity_V256, mkexpr(addr)));
16725 putYMMReg( rG, mkexpr(res) );
16755 mkexpr(andV), mkexpr(andV)),
16757 mkexpr(andV), mkexpr(andV)))));
16763 mkexpr(andnV), mkexpr(andnV)),
16765 mkexpr(andnV), mkexpr(andnV)))));
16774 binop(Iop_Sar64, mkexpr(and64), mkU8(63))));
16778 binop(Iop_Sar64, mkexpr(andn64), mkU8(63))));
16787 assign(t1, binop(Iop_And64, mkexpr(and64), mkexpr(t0)));
16788 assign(t2, binop(Iop_And64, mkexpr(andn64), mkexpr(t0)));
16801 binop(Iop_Sub64, mkU64(0), mkexpr(and64)),
16802 mkexpr(and64)), mkU8(63))));
16808 binop(Iop_Sub64, mkU64(0), mkexpr(andn64)),
16809 mkexpr(andn64)), mkU8(63))));
16817 binop(Iop_And64, mkexpr(z64), mkU64(AMD64G_CC_MASK_Z)),
16818 binop(Iop_And64, mkexpr(c64), mkU64(AMD64G_CC_MASK_C))));
16820 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(newOSZACP)));
16852 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
16869 assign(andV, binop(Iop_AndV128, mkexpr(vecE), mkexpr(vecG)));
16871 mkexpr(vecE),
16872 binop(Iop_XorV128, mkexpr(vecG),
16902 assign(vecE, loadLE( Ity_V256, mkexpr(addr) ));
16918 assign(andV, binop(Iop_AndV256, mkexpr(vecE), mkexpr(vecG)));
16920 mkexpr(vecE), unop(Iop_NotV256, mkexpr(vecG))));
16931 assign( andV128, binop( Iop_OrV128, mkexpr(andVhi), mkexpr(andVlo) ) );
16932 assign( andnV128, binop( Iop_OrV128, mkexpr(andnVhi), mkexpr(andnVlo) ) );
16959 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
16967 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) )
16972 mkexpr(srcVec) ),
17000 assign( srcVec, loadLE( Ity_V128, mkexpr(addr) ) );
17009 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ),
17011 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ) );
17043 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
17050 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) );
17080 assign( srcVec, loadLE( Ity_V128, mkexpr(addr) ) );
17088 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ),
17090 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ) );
17119 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
17127 unop( Iop_32HIto16, mkexpr(srcBytes) ) ),
17129 unop( Iop_32to16, mkexpr(srcBytes) ) ) ) );
17152 assign( srcBytes, loadLE( Ity_I64, mkexpr(addr) ) );
17160 unop( Iop_16Sto64, mkexpr(s3) ),
17161 unop( Iop_16Sto64, mkexpr(s2) ) ),
17163 unop( Iop_16Sto64, mkexpr(s1) ),
17164 unop( Iop_16Sto64, mkexpr(s0) ) ) ) );
17188 unop( Iop_32UtoV128, loadLE( Ity_I32, mkexpr(addr) ) ) );
17198 mkexpr(zeroVec),
17200 mkexpr(zeroVec), mkexpr(srcVec) ) ) );
17223 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
17233 mkexpr(zeroVec),
17235 mkexpr(zeroVec), mkexpr(srcVec) ) ),
17237 mkexpr(zeroVec),
17239 mkexpr(zeroVec), mkexpr(srcVec) ) ) ) );
17264 assign( srcI64, unop(Iop_V128to64, mkexpr(srcVec)) );
17269 assign( srcI64, loadLE(Ity_I64, mkexpr(addr)) );
17270 assign( srcVec, unop( Iop_64UtoV128, mkexpr(srcI64)) );
17278 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) )
17281 unop( Iop_64HIto32, mkexpr(srcI64) ) ),
17283 unop( Iop_64to32, mkexpr(srcI64) ) ) );
17313 assign( srcVec, loadLE(Ity_V128, mkexpr(addr)) );
17322 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ),
17324 IRExpr_Const( IRConst_V128(0) ), mkexpr(srcVec) ) );
17331 unop( Iop_32Sto64, mkexpr(s3) ),
17332 unop( Iop_32Sto64, mkexpr(s2) ) ),
17334 unop( Iop_32Sto64, mkexpr(s1) ),
17335 unop( Iop_32Sto64, mkexpr(s0) ) ) );
17364 unop( Iop_32UtoV128, loadLE( Ity_I32, mkexpr(addr) ) ) );
17374 mkexpr(zeroVec),
17376 mkexpr(zeroVec), mkexpr(srcVec)));
17406 unop( Iop_64UtoV128, loadLE( Ity_I64, mkexpr(addr) ) ) );
17417 mkexpr(zeroVec),
17419 mkexpr(zeroVec), mkexpr(srcVec)) ),
17421 mkexpr(zeroVec),
17423 mkexpr(zeroVec), mkexpr(srcVec)) ) );
17452 assign( srcBytes, loadLE( Ity_I16, mkexpr(addr) ) );
17460 unop( Iop_16HIto8, mkexpr(srcBytes) ) ),
17462 unop( Iop_16to8, mkexpr(srcBytes) ) ) ) );
17484 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
17495 mkexpr(srcBytes) ) ) ),
17499 mkexpr(srcBytes) ) ) ) ),
17504 mkexpr(srcBytes) ) ) ),
17508 mkexpr(srcBytes) ) ) ) ) ) );
17533 unop( Iop_16Uto32, loadLE( Ity_I16, mkexpr(addr) ))));
17543 mkexpr(zeroVec),
17545 mkexpr(zeroVec),
17547 mkexpr(zeroVec), mkexpr(srcVec) ) ) ) );
17570 unop( Iop_32UtoV128, loadLE( Ity_I32, mkexpr(addr) )));
17581 mkexpr(zeroVec),
17583 mkexpr(zeroVec),
17585 mkexpr(zeroVec), mkexpr(srcVec) ) ) ),
17587 mkexpr(zeroVec),
17589 mkexpr(zeroVec),
17591 mkexpr(zeroVec), mkexpr(srcVec) ) ) )
17619 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
17623 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
17624 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
17629 mkIRExprVec_2( mkexpr(sLo), mkexpr(sHi) )
17632 (rG, unop(Iop_64UtoV128, mkexpr(dLo)));
17661 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
17750 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
17853 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
17863 putXMMReg(gregOfRexRM(pfx, modrm), mkexpr(res));
17956 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
17961 putXMMReg( rG, mkexpr(math_PMULDQ_128( dV, sV )) );
17987 loadLE(Ity_V128, mkexpr(addr)) );
18015 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
18025 mkexpr(argL), mkexpr(argR)) );
18198 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
18207 binop( Iop_Mul32x4, mkexpr(argL), mkexpr(argR)) );
18264 assign(valE, loadLE(tyE, mkexpr(addr)));
18294 mkIRExprVec_2(mkexpr(valG0),
18295 widenUto64(mkexpr(valE)))));
18297 putIRegG(4, pfx, modrm, unop(Iop_64to32, mkexpr(valG1)));
18352 case 0: assign(d16, unop(Iop_32to16, mkexpr(t0))); break;
18353 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(t0))); break;
18354 case 2: assign(d16, unop(Iop_32to16, mkexpr(t1))); break;
18355 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(t1))); break;
18356 case 4: assign(d16, unop(Iop_32to16, mkexpr(t2))); break;
18357 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(t2))); break;
18358 case 6: assign(d16, unop(Iop_32to16, mkexpr(t3))); break;
18359 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(t3))); break;
18365 putIReg32( rE, unop(Iop_16Uto32, mkexpr(d16)) );
18370 storeLE( mkexpr(addr), mkexpr(d16) );
18408 case 0: assign( src_dword, mkexpr(t0) ); break;
18409 case 1: assign( src_dword, mkexpr(t1) ); break;
18410 case 2: assign( src_dword, mkexpr(t2) ); break;
18411 case 3: assign( src_dword, mkexpr(t3) ); break;
18416 putIReg32( eregOfRexRM(pfx,modrm), mkexpr(src_dword) );
18422 storeLE( mkexpr(addr), mkexpr(src_dword) );
18456 case 0: assign( src_qword, unop(Iop_V128to64, mkexpr(xmm_vec)) );
18458 case 1: assign( src_qword, unop(Iop_V128HIto64, mkexpr(xmm_vec)) );
18464 putIReg64( eregOfRexRM(pfx,modrm), mkexpr(src_qword) );
18470 storeLE( mkexpr(addr), mkexpr(src_qword) );
18502 binop(Iop_CmpEQ8x16, mkexpr(argL), mkV128(0)))));
18506 binop(Iop_CmpEQ8x16, mkexpr(argR), mkV128(0)))));
18516 IRExpr *ctzL = unop(Iop_32to8, math_CTZ32(mkexpr(zmaskL)));
18523 assign(zmaskL_zero, binop(Iop_ExpCmpNE32, mkexpr(zmaskL), mkU32(0)));
18527 IRExpr_ITE(mkexpr(zmaskL_zero),
18533 IRExpr *ctzR = unop(Iop_32to8, math_CTZ32(mkexpr(zmaskR)));
18535 assign(zmaskR_zero, binop(Iop_ExpCmpNE32, mkexpr(zmaskR), mkU32(0)));
18538 IRExpr_ITE(mkexpr(zmaskR_zero),
18546 binop(Iop_CmpEQ8x16, mkexpr(argL),
18547 mkexpr(argR))));
18553 mkexpr(validL), mkexpr(validR)));
18557 mkexpr(validL), mkexpr(validR)));
18566 binop(Iop_Xor32, intRes1, mkexpr(validL))));
18572 mkexpr(intRes2), mkU32(0x10000)));
18580 IRExpr *c_bit = IRExpr_ITE( binop(Iop_ExpCmpNE32, mkexpr(intRes2),
18585 IRExpr *z_bit = IRExpr_ITE( mkexpr(zmaskL_zero),
18589 IRExpr *s_bit = IRExpr_ITE( mkexpr(zmaskR_zero),
18593 IRExpr *o_bit = binop(Iop_Shl32, binop(Iop_And32, mkexpr(intRes2),
18603 stmt(IRStmt_Put(OFFB_CC_DEP1, mkexpr(cc)));
18642 stmt( IRStmt_Put( OFFB_YMM16, loadLE(Ity_V128, mkexpr(addr)) ));
18731 binop(Iop_Shr64, mkexpr(resT), mkU8(16)),
18741 binop(Iop_And64, mkexpr(resT), mkU64(0xFFFF))
18760 unop(Iop_8Uto64, mkexpr(u8)),
18763 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
18765 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
18771 mkexpr(tmp128),
18772 binop(Iop_AndV128, mkexpr(v128), mkV128(mask))) );
18804 mkexpr(withZs),
18805 binop( Iop_AndV128, mkexpr(v128), mkV128(mask) ) ) );
18818 assign(withZs, binop(Iop_64HLtoV128, mkU64(0), mkexpr(u64)));
18822 assign( withZs, binop(Iop_64HLtoV128, mkexpr(u64), mkU64(0)));
18827 mkexpr(withZs),
18828 binop( Iop_AndV128, mkexpr(v128), mkV128(mask) ) ) );
18879 case 0: assign( sel_lane, mkexpr(t0) ); break;
18880 case 1: assign( sel_lane, mkexpr(t1) ); break;
18881 case 2: assign( sel_lane, mkexpr(t2) ); break;
18882 case 3: assign( sel_lane, mkexpr(t3) ); break;
18886 binop( Iop_Shr32, mkexpr(sel_lane), mkU8(((imm8 & 3)*8)) ) );
18891 binop(Iop_And32, mkexpr(shr_lane), mkU32(255)) ) );
18897 storeLE( mkexpr(addr), unop(Iop_32to8, mkexpr(shr_lane) ) );
18917 mkexpr(rm),
18918 mkexpr(dst_vec), mkexpr(src_vec) ),
18923 mkexpr(and_vec), mkexpr(and_vec) ),
18925 mkexpr(and_vec), mkexpr(and_vec) ) ) );
18929 mkexpr(sum_vec), mkexpr(sum_vec) ),
18953 mkexpr(rm), mkexpr(dst_vec), mkexpr(src_vec) ),
18959 mkexpr(rm),
18961 mkexpr(prod_vec), mkexpr(prod_vec) ),
18963 mkexpr(prod_vec), mkexpr(prod_vec) ) ) );
18968 mkexpr(rm),
18970 mkexpr(sum_vec), mkexpr(sum_vec) ),
18972 mkexpr(sum_vec), mkexpr(sum_vec) ) ),
18994 assign(src_masked, binop(Iop_AndV128, mkexpr(src_vec), mkexpr(src_maskV)));
18995 assign(dst_masked, binop(Iop_AndV128, mkexpr(dst_vec), mkexpr(dst_maskV)));
19000 assign( sHi, unop(Iop_V128HIto64, mkexpr(src_masked)) );
19001 assign( sLo, unop(Iop_V128to64, mkexpr(src_masked)) );
19005 assign( dHi, unop(Iop_V128HIto64, mkexpr(dst_masked)) );
19006 assign( dLo, unop(Iop_V128to64, mkexpr(dst_masked)) );
19013 = mkIRExprVec_5( mkexpr(sHi), mkexpr(sLo), mkexpr(dHi), mkexpr(dLo),
19016 = mkIRExprVec_5( mkexpr(sHi), mkexpr(sLo), mkexpr(dHi), mkexpr(dLo),
19027 assign(res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo)));
19056 case 0: assign( src_dword, mkexpr(t0) ); break;
19057 case 1: assign( src_dword, mkexpr(t1) ); break;
19058 case 2: assign( src_dword, mkexpr(t2) ); break;
19059 case 3: assign( src_dword, mkexpr(t3) ); break;
19065 putIReg32( rE, mkexpr(src_dword) );
19070 storeLE( mkexpr(addr), mkexpr(src_dword) );
19085 mkexpr(dV)));
19087 mkexpr(sV)));
19094 args = mkIRExprVec_3(mkexpr(t0), mkexpr(t1), mkU64(0));
19097 args = mkIRExprVec_3(mkexpr(t0), mkexpr(t1), mkU64(1));
19102 assign(res, binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)));
19161 binop(Iop_Add64, mkexpr(addr), mkU64(0) )));
19163 binop(Iop_Add64, mkexpr(addr), mkU64(4) )));
19165 binop(Iop_Add64, mkexpr(addr), mkU64(8) )));
19167 binop(Iop_Add64, mkexpr(addr), mkU64(12) )));
19181 assign(res0, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src0)) );
19182 assign(res1, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src1)) );
19183 assign(res2, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src2)) );
19184 assign(res3, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src3)) );
19186 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 0, mkexpr(res0) );
19187 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 1, mkexpr(res1) );
19188 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 2, mkexpr(res2) );
19189 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 3, mkexpr(res3) );
19223 binop(Iop_Add64, mkexpr(addr), mkU64(0) )));
19225 binop(Iop_Add64, mkexpr(addr), mkU64(8) )));
19239 assign(res0, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src0)) );
19240 assign(res1, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src1)) );
19242 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 0, mkexpr(res0) );
19243 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 1, mkexpr(res1) );
19276 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
19292 mkexpr(src)) );
19295 putXMMRegLane64F( gregOfRexRM(pfx, modrm), 0, mkexpr(res) );
19297 putXMMRegLane32F( gregOfRexRM(pfx, modrm), 0, mkexpr(res) );
19327 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19335 mkexpr( math_BLENDPS_128( src_vec, dst_vec, imm8) ) );
19363 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19371 mkexpr( math_BLENDPD_128( src_vec, dst_vec, imm8) ) );
19400 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19408 mkexpr( math_PBLENDW_128( src_vec, dst_vec, imm8) ) );
19484 assign( new8, loadLE( Ity_I8, mkexpr(addr) ) );
19492 putXMMReg( rG, mkexpr(res) );
19521 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
19531 putXMMReg( rG, mkexpr(math_INSERTPS( vG, d2ins, imm8 )) );
19556 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
19565 putXMMReg( rG, mkexpr(res_vec) );
19587 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
19596 putXMMReg( rG, mkexpr(res_vec) );
19622 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19629 putXMMReg( rG, mkexpr(res) );
19655 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19662 putXMMReg( rG, mkexpr(res) );
19691 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19697 putXMMReg( rG, mkexpr( math_MPSADBW_128(dst_vec, src_vec, imm8) ) );
19728 assign( svec, loadLE( Ity_V128, mkexpr(addr) ) );
19735 putXMMReg( rG, mkexpr( math_PCLMULQDQ(dvec, svec, imm8) ) );
20089 putIReg64(R_RSP, mkexpr(t2) );
20090 storeLE(mkexpr(t2),mkexpr(t1));
20109 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
20110 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t2), mkU64(sz)));
20111 putIRegRexB(sz, pfx, opc-0x58, mkexpr(t1));
20135 loadLE(Ity_I32, mkexpr(addr))));
20168 putIReg64(R_RSP, mkexpr(t1) );
20173 storeLE( mkexpr(t1), mkU(ty,d64) );
20335 putIRegG(sz, pfx, modrm, mkexpr(t1));
20336 putIRegE(sz, pfx, modrm, mkexpr(t2));
20344 assign( t1, loadLE(ty, mkexpr(addr)) );
20346 casLE( mkexpr(addr),
20347 mkexpr(t1), mkexpr(t2), guest_RIP_curr_instr );
20348 putIRegG( sz, pfx, modrm, mkexpr(t1) );
20403 ? unop(Iop_64to32, mkexpr(addr))
20404 : mkexpr(addr)
20432 assign( t3, loadLE(Ity_I64, mkexpr(t1)) );
20439 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t1), mkU64(sz)) );
20442 storeLE( mkexpr(addr), mkexpr(t3) );
20530 putIReg64(R_RSP, mkexpr(t1) );
20539 mkexpr(t2),
20548 mkexpr(t3),
20558 mkexpr(t4),
20567 storeLE( mkexpr(t1), unop(Iop_32to16,
20568 unop(Iop_64to32,mkexpr(t5))) );
20570 storeLE( mkexpr(t1), mkexpr(t5) );
20585 assign(t1, widenUto64(loadLE(szToITy(sz),mkexpr(t2))));
20586 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t2), mkU64(sz)));
20593 mkexpr(t1),
20608 binop(Iop_Shr64, mkexpr(t1), mkU8(10)),
20620 binop(Iop_Shr64, mkexpr(t1), mkU8(21)),
20632 binop(Iop_Shr64, mkexpr(t1), mkU8(18)),
20663 putIRegRAX(sz, loadLE( ty, mkexpr(addr) ));
20681 storeLE( mkexpr(addr), getIRegRAX(sz) );
20902 storeLE(mkexpr(addr),
20962 putIReg64(R_RSP, mkexpr(t2));
20963 storeLE(mkexpr(t2), mkexpr(t1));
20964 putIReg64(R_RBP, mkexpr(t2));
20966 putIReg64(R_RSP, binop(Iop_Sub64, mkexpr(t2), mkU64(d64)));
20982 putIReg64(R_RSP, mkexpr(t1));
20983 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
20984 putIReg64(R_RBP, mkexpr(t2));
20985 putIReg64(R_RSP, binop(Iop_Add64, mkexpr(t1), mkU64(8)) );
21230 mkIRExprVec_2( mkexpr(t1), mkU64(sz) )
21234 putIRegRAX(sz, narrowTo( ty, mkexpr(t2) ) );
21277 mkIRExprVec_3( mkexpr(t1),
21293 putIReg64(R_RSP, mkexpr(t1));
21294 storeLE( mkexpr(t1), mkU64(guest_RIP_bbstart+delta));
21351 assign( t2, binop(Iop_Xor64, mkexpr(t1),
21356 assign( t2, binop(Iop_And64, mkexpr(t1),
21361 assign( t2, binop(Iop_Or64, mkexpr(t1),
21370 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t2) ));
21453 binop(Iop_And64,mkexpr(t1),mkexpr(m8)),
21456 binop(Iop_Shl64,mkexpr(t1),mkU8(8)),
21457 mkexpr(m8))
21465 binop(Iop_And64,mkexpr(s8),mkexpr(m16)),
21468 binop(Iop_Shl64,mkexpr(s8),mkU8(16)),
21469 mkexpr(m16))
21477 binop(Iop_And64,mkexpr(s16),mkexpr(m32)),
21480 binop(Iop_Shl64,mkexpr(s16),mkU8(32)),
21481 mkexpr(m32))
21490 binop(Iop_Shl32, mkexpr(t1), mkU8(24)),
21493 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t1), mkU8(8)),
21496 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(8)),
21498 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(24)),
21507 binop(Iop_Shl16, mkexpr(t1), mkU8(8)),
21508 binop(Iop_Shr16, mkexpr(t1), mkU8(8)) ));
21567 mkIRExprVec_2( mkexpr(addr),
21572 d->mAddr = mkexpr(addr);
21586 stmt( IRStmt_Exit(binop(Iop_CmpNE32, mkexpr(t1), mkU32(0)),
21716 putIRegRDX(4, unop(Iop_64HIto32, mkexpr(val)));
21717 putIRegRAX(4, unop(Iop_64to32, mkexpr(val)));
21842 putIRegE(1, pfx, modrm, mkexpr(t1));
21848 storeLE( mkexpr(addr), mkexpr(t1) );
22212 assign( expdHi, sz==4 ? unop(Iop_64to32, mkexpr(expdHi64))
22213 : mkexpr(expdHi64) );
22214 assign( expdLo, sz==4 ? unop(Iop_64to32, mkexpr(expdLo64))
22215 : mkexpr(expdLo64) );
22222 Iend_LE, mkexpr(addr),
22223 mkexpr(expdHi), mkexpr(expdLo),
22224 mkexpr(dataHi), mkexpr(dataLo)
22231 binop(opXOR, mkexpr(oldHi), mkexpr(expdHi)),
22232 binop(opXOR, mkexpr(oldLo), mkexpr(expdLo))
22254 IRExpr_ITE( mkexpr(success),
22255 mkexpr(expdHi64),
22256 sz == 4 ? unop(Iop_32Uto64, mkexpr(oldHi))
22257 : mkexpr(oldHi)
22260 IRExpr_ITE( mkexpr(success),
22261 mkexpr(expdLo64),
22262 sz == 4 ? unop(Iop_32Uto64, mkexpr(oldLo))
22263 : mkexpr(oldLo)
22272 binop(Iop_And64, mkexpr(flags_old),
22276 unop(Iop_1Uto64, mkexpr(success)), mkU64(1)),
22280 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(flags_new) ));
22309 putIRegRexB(4, pfx, opc-0xC8, mkexpr(t2));
22318 putIRegRexB(8, pfx, opc-0xC8, mkexpr(t2));
22507 assign(src, loadLE(ty, mkexpr(addr)));
22509 putIRegG(sz, pfx, modrm, mkexpr(dst));
22514 storeLE(mkexpr(addr), mkexpr(dst));
22646 assign(tSR, loadLE(Ity_V128, mkexpr(addr)));
22659 ? triop(op, mkexpr(rm), mkexpr(tSR), mkexpr(tSL))
22660 : triop(op, mkexpr(rm), mkexpr(tSL), mkexpr(tSR)));
22663 ? binop(op, mkexpr(tSR), mkexpr(tSL))
22664 : binop(op, mkexpr(tSL), mkexpr(tSR)));
22671 putYMMRegLoAndZU(rD, mkexpr(res));
22734 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
22739 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
22759 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
22760 binop(op, mkexpr(g0), mkexpr(amt8)),
22769 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
22770 binop(op, mkexpr(g0), mkexpr(amt8)),
22771 binop(op, mkexpr(g0), mkU8(size-1))
22778 putYMMRegLoAndZU( rG, mkexpr(g1) );
22808 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
22813 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
22833 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
22834 binop(op, mkexpr(g0), mkexpr(amt8)),
22843 binop(Iop_CmpLT64U, mkexpr(amt), mkU64(size)),
22844 binop(op, mkexpr(g0), mkexpr(amt8)),
22845 binop(op, mkexpr(g0), mkU8(size-1))
22852 putYMMReg( rG, mkexpr(g1) );
22887 assign( amt, loadLE(isYMM ? Ity_V256 : Ity_V128, mkexpr(addr)) );
22942 mkexpr(amts[i]),
22944 binop(op, mkexpr(sVs[i]),
22946 mkexpr(amts[i]))),
22947 op == Iop_Sar32 ? binop(op, mkexpr(sVs[i]), mkU8(size-1))
22955 ? mkexpr(res[i]) : mkU32(0) );
22960 ? mkexpr(res[i]) : mkU64(0) );
23009 : binop(op, mkexpr(e0), mkU8(amt))
23014 ? binop(op, mkexpr(e0), mkU8(size-1))
23015 : binop(op, mkexpr(e0), mkU8(amt))
23021 putYMMRegLoAndZU( rD, mkexpr(e1) );
23067 : binop(op, mkexpr(e0), mkU8(amt))
23072 ? binop(op, mkexpr(e0), mkU8(size-1))
23073 : binop(op, mkexpr(e0), mkU8(amt))
23079 putYMMReg( rD, mkexpr(e1) );
23115 loadLE(Ity_I64, mkexpr(addr))) );
23116 putXMMReg( rG, binop(op, vpart, mkexpr(epart)) );
23156 assign(e64, loadLE(Ity_I64, mkexpr(addr)));
23166 getXMMReg(rV), mkexpr(e64)));
23168 putYMMRegLoAndZU( rG, unop(op, mkexpr(arg)) );
23203 assign(e32, loadLE(Ity_I32, mkexpr(addr)));
23213 getXMMReg(rV), mkexpr(e32)));
23215 putYMMRegLoAndZU( rG, unop(op, mkexpr(arg)) );
23252 loadLE(Ity_I32, mkexpr(addr))) );
23253 putXMMReg( rG, binop(op, vpart, mkexpr(epart)) );
23322 all_lanes ? loadLE(Ity_V128, mkexpr(addr))
23323 : sz == 8 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
23324 : /*sz==4*/ unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr))));
23330 assign(plain, preSwap ? binop(op, mkexpr(argR), mkexpr(argL))
23331 : binop(op, mkexpr(argL), mkexpr(argR)));
23337 putYMMRegLoAndZU( rG, unop(Iop_NotV128, mkexpr(plain)) );
23339 putYMMRegLoAndZU( rG, mkexpr(plain) );
23350 putYMMRegLoAndZU( rG, binop(Iop_XorV128, mkexpr(plain),
23353 putYMMRegLoAndZU( rG, mkexpr(plain) );
23371 unop(Iop_NotV128, mkexpr(plain)),
23372 mkexpr(mask)),
23373 binop(Iop_AndV128, mkexpr(argL), mkexpr(notMask))));
23378 mkexpr(plain),
23379 mkexpr(mask)),
23380 binop(Iop_AndV128, mkexpr(argL), mkexpr(notMask))));
23382 putYMMRegLoAndZU( rG, mkexpr(res) );
23437 assign(argR, loadLE(Ity_V256, mkexpr(addr)) );
23446 binop(op, mkexpr(argLhi), mkexpr(argRhi)),
23447 binop(op, mkexpr(argLlo), mkexpr(argRlo)) ) );
23452 putYMMReg( rG, unop(Iop_NotV256, mkexpr(plain)) );
23454 putYMMReg( rG, mkexpr(plain) );
23484 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
23489 putYMMRegLoAndZU( rG, mkexpr(res) );
23515 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
23523 IRExpr* res = needsIRRM ? binop(op, get_FAKE_roundingmode(), mkexpr(arg))
23524 : unop(op, mkexpr(arg));
23565 assign(tSR, loadLE(Ity_V256, mkexpr(addr)));
23578 ? triop(op, mkexpr(rm), mkexpr(tSR), mkexpr(tSL))
23579 : triop(op, mkexpr(rm), mkexpr(tSL), mkexpr(tSR)));
23582 ? binop(op, mkexpr(tSR), mkexpr(tSL))
23583 : binop(op, mkexpr(tSL), mkexpr(tSR)));
23590 putYMMReg(rD, mkexpr(res));
23665 assign(arg, loadLE(Ity_V256, mkexpr(addr)));
23670 putYMMReg( rG, mkexpr(res) );
23696 assign(arg, loadLE(Ity_V256, mkexpr(addr)));
23700 putYMMReg( rG, unop(op, mkexpr(arg)) );
23724 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
23734 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s3))),
23735 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s2))),
23736 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s1))),
23737 unop(Iop_ReinterpF64asI64, unop(Iop_I32StoF64, mkexpr(s0)))
23761 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
23770 # define CVT(_t) binop( Iop_F64toF32, mkexpr(rmode), \
23771 unop(Iop_ReinterpI64asF64, mkexpr(_t)) )
23790 binop( op, mkexpr(tRhi), mkexpr(tLhi) ),
23791 binop( op, mkexpr(tRlo), mkexpr(tLlo) ) ) );
23901 putXMMReg( rG, mkexpr(z128) );
23903 putXMMRegLane64( rG, 0, loadLE(Ity_I64, mkexpr(addr)) );
23904 putYMMRegLane128( rG, 1, mkexpr(z128) );
23923 putYMMRegLoAndZU(rG, mkexpr(res));
23936 putXMMReg( rG, mkexpr(z128) );
23938 mkexpr(addr)) );
23939 putYMMRegLane128( rG, 1, mkexpr(z128) );
23960 putYMMRegLoAndZU(rG, mkexpr(res));
23975 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
23992 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
24009 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
24026 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
24042 storeLE( mkexpr(addr), getXMMRegLane64(rG, 0));
24061 putYMMRegLoAndZU(rG, mkexpr(res));
24072 storeLE( mkexpr(addr), getXMMRegLane32(rG, 0));
24093 putYMMRegLoAndZU(rG, mkexpr(res));
24108 storeLE( mkexpr(addr), getXMMReg(rG) );
24125 storeLE( mkexpr(addr), getYMMReg(rG) );
24142 storeLE( mkexpr(addr), getXMMReg(rG) );
24159 storeLE( mkexpr(addr), getYMMReg(rG) );
24193 putYMMRegLoAndZU(rG, mkexpr(res));
24213 loadLE(Ity_I64, mkexpr(addr))));
24214 putYMMRegLoAndZU(rG, mkexpr(res));
24242 storeLE( mkexpr(addr), getXMMRegLane64( rG, 0));
24268 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
24274 putYMMRegLoAndZU( rG, mkexpr(res) );
24296 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
24302 putYMMReg( rG, mkexpr(res) );
24324 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
24330 putYMMRegLoAndZU( rG, mkexpr(res) );
24352 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
24358 putYMMReg( rG, mkexpr(res) );
24380 putYMMRegLoAndZU(rG, mkexpr(res));
24399 loadLE(Ity_I64, mkexpr(addr)),
24401 putYMMRegLoAndZU(rG, mkexpr(res));
24429 storeLE( mkexpr(addr), getXMMRegLane64( rG, 1));
24449 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
24467 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
24485 putYMMRegLoAndZU( rG, loadLE(Ity_V128, mkexpr(addr)) );
24503 putYMMReg( rG, loadLE(Ity_V256, mkexpr(addr)) );
24524 storeLE( mkexpr(addr), getXMMReg(rG) );
24542 storeLE( mkexpr(addr), getYMMReg(rG) );
24561 storeLE( mkexpr(addr), getXMMReg(rG) );
24580 storeLE( mkexpr(addr), getYMMReg(rG) );
24605 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
24611 unop(Iop_I32StoF64, mkexpr(arg32)));
24631 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
24639 mkexpr(arg64)) );
24659 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
24666 mkexpr(rmode),
24667 binop(Iop_I64StoF64, mkexpr(rmode),
24668 mkexpr(arg64)) ) );
24689 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
24696 mkexpr(rmode),
24697 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
24719 storeLE(mkexpr(addr), mkexpr(tS));
24735 storeLE(mkexpr(addr), mkexpr(tS));
25147 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)) );
25153 binop( Iop_F64toF32, mkexpr(rmode),
25154 mkexpr(f64lo)) );
25175 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)) );
25181 unop( Iop_F32toF64, mkexpr(f32lo)) );
25672 unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)))
25697 unop( Iop_64UtoV128,loadLE(Ity_I64, mkexpr(addr)))
25726 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
25729 putYMMReg(rD, mkexpr(tD));
25751 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
25754 putYMMRegLoAndZU(rD, mkexpr(tD));
25919 putYMMRegLoAndZU(rD, mkexpr(math_PSRLDQ( vecS, imm )));
25928 putYMMRegLoAndZU(rD, mkexpr(math_PSLLDQ( vecS, imm )));
25962 putYMMRegLane128(rD, 0, mkexpr(math_PSRLDQ( vecS0, imm )));
25963 putYMMRegLane128(rD, 1, mkexpr(math_PSRLDQ( vecS1, imm )));
25975 putYMMRegLane128(rD, 0, mkexpr(math_PSLLDQ( vecS0, imm )));
25976 putYMMRegLane128(rD, 1, mkexpr(math_PSLLDQ( vecS1, imm )));
26054 putYMMRegLane128(i, 1, mkexpr(zero128));
26065 putYMMRegLoAndZU(i, mkexpr(zero128));
26092 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
26098 putYMMRegLoAndZU( rG, mkexpr( math_HADDPS_128 ( dV, sV, isAdd ) ) );
26122 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
26131 mkexpr( math_HADDPS_128 ( d1, s1, isAdd ) ),
26132 mkexpr( math_HADDPS_128 ( d0, s0, isAdd ) ) ) );
26154 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
26160 putYMMRegLoAndZU( rG, mkexpr( math_HADDPD_128 ( dV, sV, isAdd ) ) );
26184 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
26193 mkexpr( math_HADDPD_128 ( d1, s1, isAdd ) ),
26194 mkexpr( math_HADDPD_128 ( d0, s0, isAdd ) ) ) );
26218 putXMMRegLane64( rG, 0, loadLE(Ity_I64, mkexpr(addr)) );
26241 storeLE( mkexpr(addr), getXMMRegLane64(rG, 0) );
26260 storeLE( mkexpr(addr), getXMMRegLane32(rG, 0) );
26282 putYMMReg(rD, mkexpr(tS));
26289 storeLE(mkexpr(addr), mkexpr(tS));
26307 putYMMRegLoAndZU(rD, mkexpr(tS));
26314 storeLE(mkexpr(addr), mkexpr(tS));
26422 assign( new16, loadLE( Ity_I16, mkexpr(addr) ));
26431 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
26469 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
26476 putYMMRegLoAndZU( rG, mkexpr(res) );
26499 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
26506 putYMMReg( rG, mkexpr(res) );
26529 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
26536 putYMMRegLoAndZU( rG, mkexpr(res) );
26559 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
26566 putYMMReg( rG, mkexpr(res) );
26702 storeLE( mkexpr(addr), getXMMRegLane64( rG, 0 ));
26986 storeLE( mkexpr(addr), getXMMReg(rG) );
27000 storeLE( mkexpr(addr), getYMMReg(rG) );
27146 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
27148 putYMMReg(rD, mkexpr(tD));
27159 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
27161 putYMMRegLoAndZU(rD, mkexpr(tD));
27422 binop(Iop_ShlN32x4, mkexpr(ctrlV), mkU8(30)),
27427 assign(res, binop(Iop_Perm32x4, mkexpr(dataV), cv1));
27440 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
27453 binop(Iop_Shr64, mkexpr(cHi), mkU8(1))),
27454 mkexpr(dHi), mkexpr(dLo) );
27457 binop(Iop_Shr64, mkexpr(cLo), mkU8(1))),
27458 mkexpr(dHi), mkexpr(dLo) );
27473 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
27482 binop(Iop_ShlN32x8, mkexpr(ctrlV), mkU8(29)),
27487 assign(res, binop(Iop_Perm32x8, mkexpr(dataV), cv1));
27511 mkexpr(addr)) );
27518 binop(mkSizedOp(ty,op8), mkexpr(src),
27519 narrowTo(Ity_I8, binop(mkSizedOp(ty,Iop_And8), mkexpr(amt),
27630 assign(vY, loadLE(vty, mkexpr(addr)));
27658 x[0] = mkexpr(vX);
27659 y[0] = mkexpr(vY);
27660 z[0] = mkexpr(vZ);
27666 assign(tem, unop(ops[i / 2 + j], mkexpr(vX)));
27667 x[i] = unop(Iop_64to32, mkexpr(tem));
27668 x[i + 1] = unop(Iop_64HIto32, mkexpr(tem));
27670 assign(tem, unop(ops[i / 2 + j], mkexpr(vY)));
27671 y[i] = unop(Iop_64to32, mkexpr(tem));
27672 y[i + 1] = unop(Iop_64HIto32, mkexpr(tem));
27674 assign(tem, unop(ops[i / 2 + j], mkexpr(vZ)));
27675 z[i] = unop(Iop_64to32, mkexpr(tem));
27676 z[i + 1] = unop(Iop_64HIto32, mkexpr(tem));
27682 x[i] = unop(ops[i + j], mkexpr(vX));
27683 y[i] = unop(ops[i + j], mkexpr(vY));
27684 z[i] = unop(ops[i + j], mkexpr(vZ));
27761 IRExpr* ea = binop(Iop_Add64, mkexpr(addr),
27767 data, ea, laneIs32 ? mkU32(0) : mkU64(0), mkexpr(cond)
27769 (laneIs32 ? putYMMRegLane32 : putYMMRegLane64)( rG, i, mkexpr(data) );
27772 stmt( IRStmt_StoreG(Iend_LE, ea, mkexpr(data), mkexpr(cond)) );
27851 addr_expr = binop(Iop_Add64, mkexpr(addr), addr_expr);
27853 addr_expr = IRExpr_ITE(mkexpr(cond), addr_expr, getIReg64(R_RSP));
27854 expr = IRExpr_ITE(mkexpr(cond), loadLE(ty, addr_expr), expr);
28012 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
28024 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
28025 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
28063 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
28076 dis_PSIGN_helper( mkexpr(s3), mkexpr(d3), laneszB ),
28077 dis_PSIGN_helper( mkexpr(s2), mkexpr(d2), laneszB )
28080 dis_PSIGN_helper( mkexpr(s1), mkexpr(d1), laneszB ),
28081 dis_PSIGN_helper( mkexpr(s0), mkexpr(d0), laneszB )
28111 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
28123 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
28124 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
28150 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
28163 dis_PMULHRSW_helper( mkexpr(s3), mkexpr(d3) ),
28164 dis_PMULHRSW_helper( mkexpr(s2), mkexpr(d2) ) ),
28166 dis_PMULHRSW_helper( mkexpr(s1), mkexpr(d1) ),
28167 dis_PMULHRSW_helper( mkexpr(s0), mkexpr(d0) ) )
28194 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
28199 putYMMRegLoAndZU(rG, mkexpr(resV));
28221 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
28226 putYMMReg(rG, mkexpr(resV));
28251 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
28256 putYMMRegLoAndZU(rG, mkexpr(resV));
28278 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
28283 putYMMReg(rG, mkexpr(resV));
28349 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
28351 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28352 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
28366 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
28368 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28369 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
28370 mkexpr(t64), mkexpr(t64));
28385 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28386 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
28402 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28403 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
28404 mkexpr(t64), mkexpr(t64));
28422 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
28423 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
28424 mkexpr(t64), mkexpr(t64));
28438 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
28439 mkexpr(t64), mkexpr(t64));
28457 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
28458 putYMMReg( rG, binop(Iop_V128HLtoV256, mkexpr(t128), mkexpr(t128)) );
28646 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
28648 putYMMRegLoAndZU(rD, mkexpr(tD));
28660 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
28662 putYMMReg(rD, mkexpr(tD));
29106 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
29109 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29110 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
29129 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
29132 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29133 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
29134 mkexpr(t64), mkexpr(t64));
29156 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
29158 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
29177 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
29179 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
29180 mkexpr(t64), mkexpr(t64));
29197 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
29198 putYMMReg( rG, binop(Iop_V128HLtoV256, mkexpr(t128), mkexpr(t128)) );
29219 assign(t8, loadLE(Ity_I8, mkexpr(addr)));
29222 assign(t16, binop(Iop_8HLto16, mkexpr(t8), mkexpr(t8)));
29224 assign(t32, binop(Iop_16HLto32, mkexprmkexpr(t16)));
29226 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29227 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
29246 assign(t8, loadLE(Ity_I8, mkexpr(addr)));
29249 assign(t16, binop(Iop_8HLto16, mkexpr(t8), mkexpr(t8)));
29251 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
29253 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29254 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
29255 mkexpr(t64), mkexpr(t64));
29277 assign(t16, loadLE(Ity_I16, mkexpr(addr)));
29280 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
29282 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29283 IRExpr* res = binop(Iop_64HLtoV128, mkexpr(t64), mkexpr(t64));
29302 assign(t16, loadLE(Ity_I16, mkexpr(addr)));
29305 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
29307 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29308 IRExpr* res = IRExpr_Qop(Iop_64x4toV256, mkexpr(t64), mkexpr(t64),
29309 mkexpr(t64), mkexpr(t64));
29675 assign( src2, loadLE(ty, mkexpr(addr)) );
29682 unop( mkSizedOp(ty,Iop_Not8), mkexpr(src1) ),
29683 mkexpr(src2) ) );
29684 putIRegG( size, pfx, rm, mkexpr(dst) );
29688 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
29713 assign( src, loadLE(ty, mkexpr(addr)) );
29720 mkexpr(src)), mkexpr(src)) );
29721 putIRegV( size, pfx, mkexpr(dst) );
29725 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
29726 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(src))) );
29747 assign( src, loadLE(ty, mkexpr(addr)) );
29753 binop(mkSizedOp(ty,Iop_Sub8), mkexpr(src),
29754 mkU(ty, 1)), mkexpr(src)) );
29755 putIRegV( size, pfx, mkexpr(dst) );
29759 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
29760 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(src))) );
29781 assign( src, loadLE(ty, mkexpr(addr)) );
29787 binop(mkSizedOp(ty,Iop_Sub8), mkexpr(src),
29788 mkU(ty, 1)), mkexpr(src)) );
29789 putIRegV( size, pfx, mkexpr(dst) );
29793 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
29794 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(src))) );
29821 assign( src1, loadLE(ty, mkexpr(addr)) );
29827 assign( start, narrowTo( Ity_I8, mkexpr(src2) ) );
29829 unop(Iop_8Uto32, mkexpr(start)),
29841 mkexpr(cond),
29843 binop(Iop_CmpEQ8, mkexpr(start), mkU8(0)),
29849 mkexpr(src1),
29850 binop(Iop_Sub8, mkU8(8*size), mkexpr(start))
29852 binop(Iop_Sub8, mkU8(8*size), mkexpr(start))
29855 mkexpr(src1)
29858 putIRegG( size, pfx, rm, mkexpr(dst) );
29862 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
29863 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto64(mkexpr(cond))) );
29884 assign( mask, loadLE(ty, mkexpr(addr)) );
29890 IRExpr** args = mkIRExprVec_2( widenUto64(mkexpr(src)),
29891 widenUto64(mkexpr(mask)) );
29917 assign( mask, loadLE(ty, mkexpr(addr)) );
29926 mkexpr(src), mkexpr(mask));
29928 widenUto64(mkexpr(mask)) );
29958 assign( src2, loadLE(ty, mkexpr(addr)) );
29965 mkexpr(src1), mkexpr(src2)) );
29967 unop(size == 8 ? Iop_128to64 : Iop_64to32, mkexpr(res)) );
29970 mkexpr(res)) );
30017 assign( src1, loadLE(ty, mkexpr(addr)) );
30023 assign( stle, narrowTo( Ity_I16, mkexpr(src2) ) );
30024 assign( start, unop( Iop_16to8, mkexpr(stle) ) );
30025 assign( len, unop( Iop_16HIto8, mkexpr(stle) ) );
30041 unop(Iop_8Uto32, mkexpr(start)),
30042 unop(Iop_8Uto32, mkexpr(len))),
30045 binop(Iop_CmpEQ8, mkexpr(len), mkU8(0)),
30048 binop(mkSizedOp(ty,Iop_Shl8), mkexpr(src1),
30051 mkexpr(start)),
30052 mkexpr(len))),
30054 mkexpr(len)))
30058 unop(Iop_8Uto32, mkexpr(start)),
30060 binop(mkSizedOp(ty,Iop_Shr8), mkexpr(src1),
30061 mkexpr(start)),
30066 putIRegG( size, pfx, rm, mkexpr(dst) );
30070 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto64(mkexpr(dst))) );
30160 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
30168 mkexpr(s[(imm8 >> 6) & 3]),
30169 mkexpr(s[(imm8 >> 4) & 3]),
30170 mkexpr(s[(imm8 >> 2) & 3]),
30171 mkexpr(s[(imm8 >> 0) & 3])));
30172 putYMMReg(rG, mkexpr(dV));
30203 assign(dV, loadLE(Ity_V128, mkexpr(addr)));
30213 putYMMRegLane32(rG, i, mkexpr((imm8 & (1<<i)) ? d[i] : s[i]));
30243 assign(dV, loadLE(Ity_V256, mkexpr(addr)));
30255 putYMMRegLane32(rG, i, mkexpr((imm8 & (1<<i)) ? d[i] : s[i]));
30281 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
30288 IRExpr* res = binop(Iop_V128HLtoV256, mkexpr(dVhi), mkexpr(dVlo));
30311 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
30314 putYMMRegLoAndZU(rG, mkexpr ( math_VPERMILPS_128 ( sV, imm8 ) ) );
30339 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
30344 assign(s1, unop(Iop_V128HIto64, mkexpr(sV)));
30345 assign(s0, unop(Iop_V128to64, mkexpr(sV)));
30348 mkexpr((imm8 & (1<<1)) ? s1 : s0),
30349 mkexpr((imm8 & (1<<0)) ? s1 : s0)));
30350 putYMMRegLoAndZU(rG, mkexpr(dV));
30372 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
30380 mkexpr((imm8 & (1<<3)) ? s3 : s2),
30381 mkexpr((imm8 & (1<<2)) ? s3 : s2),
30382 mkexpr((imm8 & (1<<1)) ? s1 : s0),
30383 mkexpr((imm8 & (1<<0)) ? s1 : s0)));
30384 putYMMReg(rG, mkexpr(dV));
30418 mkexpr(addr), mkU64(0))));
30420 mkexpr(addr), mkU64(16))));
30425 putYMMRegLane128(rG, 0, mkexpr(SEL((imm8 >> 0) & 3)));
30426 putYMMRegLane128(rG, 1, mkexpr(SEL((imm8 >> 4) & 3)));
30460 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
30475 # define CVT(s) binop(Iop_RoundF32toInt, mkexpr(rm), \
30476 unop(Iop_ReinterpI32asF32, mkexpr(s)))
30512 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
30526 # define CVT(s) binop(Iop_RoundF32toInt, mkexpr(rm), \
30527 unop(Iop_ReinterpI32asF32, mkexpr(s)))
30563 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
30578 # define CVT(s) binop(Iop_RoundF64toInt, mkexpr(rm), \
30579 unop(Iop_ReinterpI64asF64, mkexpr(s)))
30609 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
30623 # define CVT(s) binop(Iop_RoundF64toInt, mkexpr(rm), \
30624 unop(Iop_ReinterpI64asF64, mkexpr(s)))
30660 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
30676 mkexpr(src)) );
30679 putXMMRegLane64F( rG, 0, mkexpr(res) );
30681 putXMMRegLane32F( rG, 0, mkexpr(res) );
30715 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30719 mkexpr( math_BLENDPS_256( sE, sV, imm8) ) );
30746 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30750 mkexpr( math_BLENDPS_128( sE, sV, imm8) ) );
30780 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30784 mkexpr( math_BLENDPD_256( sE, sV, imm8) ) );
30811 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30815 mkexpr( math_BLENDPD_128( sE, sV, imm8) ) );
30845 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30849 mkexpr( math_PBLENDW_128( sE, sV, imm8) ) );
30878 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30884 mkexpr( math_PBLENDW_128( sEhi, sVhi, imm8) ),
30885 mkexpr( math_PBLENDW_128( sElo, sVlo, imm8) ) ) );
30913 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
30921 putYMMRegLoAndZU( rG, mkexpr(res) );
30948 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
30958 mkexpr( math_PALIGNR_XMM( sHi, dHi, imm8 ) ),
30959 mkexpr( math_PALIGNR_XMM( sLo, dLo, imm8 ) ) )
31029 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
31038 putYMMRegLane128(rG, ib & 1, mkexpr(t128));
31059 putYMMRegLoAndZU(rD, mkexpr(t128));
31067 storeLE(mkexpr(addr), mkexpr(t128));
31097 assign( src_u8, loadLE( Ity_I8, mkexpr(addr) ) );
31106 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
31136 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
31146 putYMMRegLoAndZU( rG, mkexpr(math_INSERTPS( vV, d2ins, imm8 )) );
31172 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
31181 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
31204 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
31213 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
31239 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
31248 putYMMRegLane128(rG, ib & 1, mkexpr(t128));
31269 putYMMRegLoAndZU(rD, mkexpr(t128));
31277 storeLE(mkexpr(addr), mkexpr(t128));
31305 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
31314 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
31335 assign( dst_vec, loadLE( Ity_V256, mkexpr(addr) ) );
31348 mkexpr( math_DPPS_128(s1, d1, imm8) ),
31349 mkexpr( math_DPPS_128(s0, d0, imm8) ) ) );
31373 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
31382 putYMMRegLoAndZU( rG, mkexpr(res_vec) );
31412 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
31419 putYMMRegLoAndZU( rG, mkexpr( math_MPSADBW_128(dst_vec,
31449 assign( src_vec, loadLE( Ity_V256, mkexpr(addr) ) );
31459 mkexpr( math_MPSADBW_128(dHi, sHi, imm8 >> 3) ),
31460 mkexpr( math_MPSADBW_128(dLo, sLo, imm8) ) ) );
31493 assign( sV, loadLE( Ity_V128, mkexpr(addr) ) );
31500 putYMMRegLoAndZU( rG, mkexpr( math_PCLMULQDQ(dV, sV, imm8) ) );
31535 mkexpr(addr), mkU64(0))));
31537 mkexpr(addr), mkU64(16))));
31542 putYMMRegLane128(rG, 0, mkexpr(SEL((imm8 >> 0) & 3)));
31543 putYMMRegLane128(rG, 1, mkexpr(SEL((imm8 >> 4) & 3)));
31661 assign( src, loadLE(ty, mkexpr(addr)) );
31669 imm8 == 0 ? mkexpr(src)
31671 binop( mkSizedOp(ty,Iop_Shr8), mkexpr(src),
31673 binop( mkSizedOp(ty,Iop_Shl8), mkexpr(src),
31797 putIReg64(R_RSP, mkexpr(t2));
31798 storeLE( mkexpr(t2), mkU64(guest_RIP_bbstart+delta));
32256 // assign(t[0], binop(Iop_Or64, mkexpr(src),
32257 // binop(Iop_Shr64, mkexpr(src), mkU8(1))));
32258 // assign(t[1], binop(Iop_Or64, mkexpr(t[0]),
32259 // binop(Iop_Shr64, mkexpr(t[0]), mkU8(2))));
32260 // assign(t[2], binop(Iop_Or64, mkexpr(t[1]),
32261 // binop(Iop_Shr64, mkexpr(t[1]), mkU8(4))));
32262 // assign(t[3], binop(Iop_Or64, mkexpr(t[2]),
32263 // binop(Iop_Shr64, mkexpr(t[2]), mkU8(8))));
32264 // assign(t[4], binop(Iop_Or64, mkexpr(t[3]),
32265 // binop(Iop_Shr64, mkexpr(t[3]), mkU8(16))));
32266 // assign(t[5], binop(Iop_Or64, mkexpr(t[4]),
32267 // binop(Iop_Shr64, mkexpr(t[4]), mkU8(32))));
32268 // assign(t[6], unop(Iop_Not64, mkexpr(t[5])));
32272 // assign(t[0], binop(Iop_Or32, mkexpr(src),
32273 // binop(Iop_Shr32, mkexpr(src), mkU8(1))));
32274 // assign(t[1], binop(Iop_Or32, mkexpr(t[0]),
32275 // binop(Iop_Shr32, mkexpr(t[0]), mkU8(2))));
32276 // assign(t[2], binop(Iop_Or32, mkexpr(t[1]),
32277 // binop(Iop_Shr32, mkexpr(t[1]), mkU8(4))));
32278 // assign(t[3], binop(Iop_Or32, mkexpr(t[2]),
32279 // binop(Iop_Shr32, mkexpr(t[2]), mkU8(8))));
32280 // assign(t[4], binop(Iop_Or32, mkexpr(t[3]),
32281 // binop(Iop_Shr32, mkexpr(t[3]), mkU8(16))));
32282 // assign(t[5], unop(Iop_Not32, mkexpr(t[4])));
32286 // assign(t[0], binop(Iop_Or16, mkexpr(src),
32287 // binop(Iop_Shr16, mkexpr(src), mkU8(1))));
32288 // assign(t[1], binop(Iop_Or16, mkexpr(t[0]),
32289 // binop(Iop_Shr16, mkexpr(t[0]), mkU8(2))));
32290 // assign(t[2], binop(Iop_Or16, mkexpr(t[1]),
32291 // binop(Iop_Shr16, mkexpr(t[1]), mkU8(4))));
32292 // assign(t[3], binop(Iop_Or16, mkexpr(t[2]),
32293 // binop(Iop_Shr16, mkexpr(t[2]), mkU8(8))));
32294 // assign(t[4], unop(Iop_Not16, mkexpr(t[3])));
