Lines Matching full:mkexpr
661 static IRExpr* mkexpr ( IRTemp tmp )
765 NULL, mkexpr(expTmp), NULL, newVal );
769 mkexpr(oldTmp), mkexpr(expTmp) ),
928 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(dep1))) );
929 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(mkexpr(dep2))) );
953 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(dep1))) );
988 IRExpr_Mux0X( mkexpr(guard),
992 IRExpr_Mux0X( mkexpr(guard),
994 widenUto32(mkexpr(res)))) );
996 IRExpr_Mux0X( mkexpr(guard),
998 widenUto32(mkexpr(resUS)))) );
1020 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(res))) );
1044 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(arg1)) ));
1045 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(mkexpr(arg2)) ));
1139 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1142 binop(plus,mkexpr(ta1),mkexpr(ta2)),
1143 mkexpr(oldcn)) );
1150 storeLE( mkexpr(taddr), mkexpr(tres) );
1154 casLE( mkexpr(taddr),
1155 mkexpr(texpVal), mkexpr(tres), restart_point );
1160 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(ta1)) ));
1161 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(binop(xor, mkexpr(ta2),
1162 mkexpr(oldcn)) )) );
1163 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
1193 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1196 binop(minus,mkexpr(ta1),mkexpr(ta2)),
1197 mkexpr(oldcn)) );
1204 storeLE( mkexpr(taddr), mkexpr(tres) );
1208 casLE( mkexpr(taddr),
1209 mkexpr(texpVal), mkexpr(tres), restart_point );
1214 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(ta1) )) );
1215 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(binop(xor, mkexpr(ta2),
1216 mkexpr(oldcn)) )) );
1217 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
1348 irsb->next = mkexpr(t);
1437 mkIRExprVec_4( mkexpr(ldt_ptr), mkexpr(gdt_ptr),
1438 mkexpr(seg_selector), virtual)
1448 binop(Iop_CmpNE32, unop(Iop_64HIto32, mkexpr(r64)), mkU32(0)),
1455 return unop(Iop_64to32, mkexpr(r64));
1837 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1842 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1844 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
1850 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1861 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
1866 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1871 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1873 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
1879 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1950 putIReg(size, eregOfRM(rm), mkexpr(dst1));
1955 putIReg(size, eregOfRM(rm), mkexpr(dst1));
1957 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
1963 putIReg(size, eregOfRM(rm), mkexpr(dst1));
1975 assign(dst0, loadLE(ty,mkexpr(addr)));
2000 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2004 casLE( mkexpr(addr),
2005 mkexpr(dst0)/*expval*/,
2006 mkexpr(dst1)/*newval*/, guest_EIP_curr_instr );
2009 storeLE(mkexpr(addr), mkexpr(dst1));
2061 putIReg(size, gregOfRM(rm), loadLE(szToITy(size), mkexpr(addr)));
2105 storeLE( mkexpr(addr), getIReg(size, gregOfRM(rm)) );
2131 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2137 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2154 putIReg(size, R_EAX, mkexpr(dst1));
2194 loadLE(szToITy(szs),mkexpr(addr)));
2199 loadLE(szToITy(szs),mkexpr(addr))));
2221 assign( dst64, binop(op, mkexpr(src64), mkexpr(t)) );
2222 putIReg( 4, R_EAX, unop(Iop_64to32,mkexpr(dst64)) );
2223 putIReg( 4, R_EDX, unop(Iop_64HIto32,mkexpr(dst64)) );
2231 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
2232 putIReg( 2, R_EAX, unop(Iop_32to16,unop(Iop_64to32,mkexpr(dst64))) );
2233 putIReg( 2, R_EDX, unop(Iop_32to16,unop(Iop_64HIto32,mkexpr(dst64))) );
2242 binop(op, mkexpr(src64),
2243 unop(widen1632, unop(widen816, mkexpr(t)))) );
2245 unop(Iop_64to32,mkexpr(dst64)))) );
2247 unop(Iop_64HIto32,mkexpr(dst64)))) );
2294 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2302 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2310 assign(dst0, loadLE(ty,mkexpr(addr)));
2335 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2338 casLE( mkexpr(addr), mkexpr(dst0)/*expVal*/,
2339 mkexpr(dst1)/*newVal*/,
2342 storeLE(mkexpr(addr), mkexpr(dst1));
2387 assign(dst0, loadLE(ty,mkexpr(addr)));
2416 = mkIRExprVec_4( widenUto32(mkexpr(dst0)), /* thing to rotate */
2429 assign( dst1, narrowTo(ty, unop(Iop_64to32, mkexpr(r64))) );
2431 stmt( IRStmt_Put( OFFB_CC_DEP1, unop(Iop_64HIto32, mkexpr(r64)) ));
2468 assign( pre32, op32==Iop_Sar32 ? widenSto32(mkexpr(dst0))
2469 : widenUto32(mkexpr(dst0)) );
2472 assign( res32, binop(op32, mkexpr(pre32), mkexpr(shift_amt)) );
2477 mkexpr(pre32),
2480 mkexpr(shift_amt), mkU8(1)),
2487 assign( dst1, narrowTo(ty, mkexpr(res32)) );
2506 assign(rot_amt, mkexpr(rot_amt32));
2508 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt32), mkU8(8*sz-1)));
2516 mkexpr(dst0),
2517 mkexpr(rot_amt)
2520 mkexpr(dst0),
2521 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
2533 mkexpr(dst0),
2534 mkexpr(rot_amt)
2537 mkexpr(dst0),
2538 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
2554 IRExpr_Mux0X( mkexpr(rot_amt32),
2558 IRExpr_Mux0X( mkexpr(rot_amt32),
2560 widenUto32(mkexpr(dst1)))) );
2562 IRExpr_Mux0X( mkexpr(rot_amt32),
2566 IRExpr_Mux0X( mkexpr(rot_amt32),
2568 mkexpr(oldFlags))) );
2573 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2584 storeLE(mkexpr(addr), mkexpr(dst1));
2654 assign( t2, widenUto32(loadLE(ty, mkexpr(t_addr))) );
2664 assign( t2m, binop(Iop_Or32, mkU32(mask), mkexpr(t2)) );
2667 assign( t2m, binop(Iop_And32, mkU32(mask), mkexpr(t2)) );
2670 assign( t2m, binop(Iop_Xor32, mkU32(mask), mkexpr(t2)) );
2682 putIReg(sz, eregOfRM(modrm), narrowTo(ty, mkexpr(t2m)));
2685 casLE( mkexpr(t_addr),
2686 narrowTo(ty, mkexpr(t2))/*expd*/,
2687 narrowTo(ty, mkexpr(t2m))/*new*/,
2690 storeLE(mkexpr(t_addr), narrowTo(ty, mkexpr(t2m)));
2702 binop(Iop_Shr32, mkexpr(t2), mkU8(src_val)),
2733 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2734 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
2735 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
2736 putIReg(4, R_EDX, mkexpr(resHi));
2737 putIReg(4, R_EAX, mkexpr(resLo));
2747 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2748 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
2749 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
2750 putIReg(2, R_EDX, mkexpr(resHi));
2751 putIReg(2, R_EAX, mkexpr(resLo));
2761 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2762 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
2763 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
2764 putIReg(2, R_EAX, mkexpr(res16));
2831 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0), mkexpr(src)));
2833 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2868 assign(t1, loadLE(ty,mkexpr(addr)));
2874 mkexpr(t1), mkU(ty,d32)));
2885 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
2887 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
2890 storeLE( mkexpr(addr), mkexpr(dst1) );
2899 assign(src, mkexpr(t1));
2901 mkexpr(dst0), mkexpr(src)));
2903 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
2906 storeLE( mkexpr(addr), mkexpr(dst1) );
2959 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
2960 putIReg(1, eregOfRM(modrm), mkexpr(t2));
2964 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
2965 putIReg(1, eregOfRM(modrm), mkexpr(t2));
2977 assign( t1, loadLE(ty, mkexpr(addr)) );
2980 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
2982 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
2985 storeLE( mkexpr(addr), mkexpr(t2) );
2990 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
2992 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
2995 storeLE( mkexpr(addr), mkexpr(t2) );
3040 mkexpr(t1), mkU(ty,1)));
3042 putIReg(sz,eregOfRM(modrm),mkexpr(t2));
3048 mkexpr(t1), mkU(ty,1)));
3050 putIReg(sz,eregOfRM(modrm),mkexpr(t2));
3056 putIReg(4, R_ESP, mkexpr(t2));
3057 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta+1));
3070 putIReg(4, R_ESP, mkexpr(t2) );
3071 storeLE( mkexpr(t2), mkexpr(t1) );
3082 assign(t1, loadLE(ty,mkexpr(addr)));
3087 mkexpr(t1), mkU(ty,1)));
3089 casLE( mkexpr(addr),
3090 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
3092 storeLE(mkexpr(addr),mkexpr(t2));
3099 mkexpr(t1), mkU(ty,1)));
3101 casLE( mkexpr(addr),
3102 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
3104 storeLE(mkexpr(addr),mkexpr(t2));
3112 putIReg(4, R_ESP, mkexpr(t2));
3113 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta+len));
3126 putIReg(4, R_ESP, mkexpr(t2) );
3127 storeLE( mkexpr(t2), mkexpr(t1) );
3180 storeLE( mkexpr(td), loadLE(ty,mkexpr(ts)) );
3182 putIReg( 4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3183 putIReg( 4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3194 putIReg( sz, R_EAX, loadLE(ty, mkexpr(ts)) );
3196 putIReg( 4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3209 storeLE( mkexpr(td), mkexpr(ta) );
3211 putIReg( 4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3226 assign( tdv, loadLE(ty,mkexpr(td)) );
3227 assign( tsv, loadLE(ty,mkexpr(ts)) );
3231 putIReg(4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3232 putIReg(4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3246 assign( tdv, loadLE(ty,mkexpr(td)) );
3249 putIReg(4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3266 stmt( IRStmt_Exit( binop(Iop_CmpEQ32,mkexpr(tc),mkU32(0)),
3270 putIReg(4, R_ECX, binop(Iop_Sub32, mkexpr(tc), mkU32(1)) );
3310 assign( te, loadLE(ty,mkexpr(addr)) );
3315 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
3317 putIReg(size, gregOfRM(rm), mkexpr(resLo) );
3354 assign(te, loadLE(ty, mkexpr(addr)));
3365 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
3369 putIReg(size, gregOfRM(rm), mkexpr(resLo));
3388 assign(src32, widenUto32( mkexpr(src) ));
3392 binop(Iop_Shl32, mkexpr(src32),
3401 binop(Iop_CmpEQ32, mkexpr(src32x), mkU32(0))),
3402 unop(Iop_Clz32, mkexpr(src32x)),
3407 assign(res, narrowTo(ty, mkexpr(res32)));
3631 loadLE(Ity_F64,mkexpr(addr))
3638 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr)))
3656 loadLE(Ity_F64,mkexpr(addr)),
3663 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr))),
3777 loadLE(Ity_F32,mkexpr(addr)))),
3792 loadLE(Ity_F32,mkexpr(addr)))),
3899 loadLE(Ity_F32, mkexpr(addr))));
3904 storeLE(mkexpr(addr),
3910 storeLE(mkexpr(addr),
3923 mkIRExprVec_1( mkexpr(addr) )
3929 d->mAddr = mkexpr(addr);
3957 put_emwarn( mkexpr(ew) );
3960 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
3989 loadLE(Ity_I16, mkexpr(addr)))
3994 put_fpround( unop(Iop_64to32, mkexpr(t64)) );
3995 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
3996 put_emwarn( mkexpr(ew) );
4002 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
4017 mkIRExprVec_1( mkexpr(addr) )
4022 d->mAddr = mkexpr(addr);
4057 mkexpr(addr),
4084 put_ST(0, mkexpr(t1));
4094 put_ST_UNCHECKED(0, mkexpr(t2));
4095 put_ST_UNCHECKED(r_src, mkexpr(t1));
4243 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
4249 mkIRExprVec_2( mkexpr(argI),
4257 mkIRExprVec_2( mkexpr(argI),
4260 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
4261 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
4263 put_ST_UNCHECKED(0, mkexpr(expF) );
4266 put_ST(0, mkexpr(sigF) );
4281 mkexpr(a1),
4282 mkexpr(a2)));
4286 mkexpr(a1),
4287 mkexpr(a2)) );
4307 mkexpr(a1),
4308 mkexpr(a2)));
4312 mkexpr(a1),
4313 mkexpr(a2)) );
4342 mkexpr(a1)));
4347 mkexpr(a1)));
4423 loadLE(Ity_I32,mkexpr(addr)))),
4438 loadLE(Ity_I32,mkexpr(addr)))),
4471 loadLE(Ity_I32, mkexpr(addr)))));
4479 loadLE(Ity_I32, mkexpr(addr))),
4571 loadLE(Ity_I32, mkexpr(addr))));
4576 storeLE( mkexpr(addr),
4583 storeLE( mkexpr(addr),
4589 storeLE( mkexpr(addr),
4600 IRExpr** args = mkIRExprVec_1 ( mkexpr(addr) );
4611 d->mAddr = mkexpr(addr);
4617 put_ST(0, unop(Iop_ReinterpI64asF64, mkexpr(val)));
4626 = mkIRExprVec_2( mkexpr(addr),
4637 d->mAddr = mkexpr(addr);
4785 loadLE(Ity_F64,mkexpr(addr))),
4799 loadLE(Ity_F64,mkexpr(addr))),
4880 mkexpr(addr)));
4885 storeLE( mkexpr(addr),
4892 storeLE(mkexpr(addr), get_ST(0));
4897 storeLE(mkexpr(addr), get_ST(0));
4909 mkIRExprVec_1( mkexpr(addr) )
4915 d->mAddr = mkexpr(addr);
4947 put_emwarn( mkexpr(ew) );
4950 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
4967 mkIRExprVec_1( mkexpr(addr) )
4972 d->mAddr = mkexpr(addr);
5007 storeLE( mkexpr(addr), sw );
5113 loadLE(Ity_I16,mkexpr(addr))))),
5129 loadLE(Ity_I16,mkexpr(addr))))),
5163 loadLE(Ity_I16, mkexpr(addr))))));
5172 loadLE(Ity_I16, mkexpr(addr)))),
5250 loadLE(Ity_I16, mkexpr(addr)))));
5255 storeLE( mkexpr(addr),
5262 storeLE( mkexpr(addr),
5268 storeLE( mkexpr(addr),
5278 loadLE(Ity_I64, mkexpr(addr))));
5283 storeLE( mkexpr(addr),
5324 putIReg( 1, R_AL, unop(Iop_16to8, mkexpr(t16)) );
5325 putIReg( 1, R_AH, unop(Iop_16HIto8, mkexpr(t16)) );
5526 argE = loadLE(Ity_I64, mkexpr(addr));
5553 putMMXReg( gregOfRM(modrm), mkexpr(res) );
5588 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
5595 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
5615 unop(Iop_1Uto8,binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size))),
5617 binop(op, mkexpr(g0), mkexpr(amt8))
5625 unop(Iop_1Uto8,binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size))),
5626 binop(op, mkexpr(g0), mkU8(size-1)),
5627 binop(op, mkexpr(g0), mkexpr(amt8))
5635 putMMXReg( gregOfRM(rm), mkexpr(g1) );
5679 : binop(op, mkexpr(e0), mkU8(amt))
5684 ? binop(op, mkexpr(e0), mkU8(size-1))
5685 : binop(op, mkexpr(e0), mkU8(amt))
5692 putMMXReg( eregOfRM(rm), mkexpr(e1) );
5734 loadLE(Ity_I32, mkexpr(addr)) ) );
5752 storeLE( mkexpr(addr),
5771 putMMXReg( gregOfRM(modrm), loadLE(Ity_I64, mkexpr(addr)) );
5790 storeLE( mkexpr(addr), getMMXReg(gregOfRM(modrm)) );
6006 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
6007 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
6011 mkexpr(regD),
6012 mkexpr(mask) ),
6014 mkexpr(olddata),
6015 unop(Iop_Not64, mkexpr(mask)))) );
6016 storeLE( mkexpr(addr), mkexpr(newdata) );
6096 assign( esrc, loadLE(ty, mkexpr(addr)) );
6130 assign( tmpL, binop(mkpair, mkexpr(esrc), mkexpr(gsrc)) );
6132 assign( tmpL, binop(mkpair, mkexpr(gsrc), mkexpr(esrc)) );
6134 assign( tmpRes, unop(getres, binop(shift, mkexpr(tmpL), mkexpr(tmpSH)) ) );
6138 mkexpr(tmpL),
6140 binop(Iop_Sub8, mkexpr(tmpSH), mkU8(1) ),
6149 putIReg(sz, eregOfRM(modrm), mkexpr(tmpRes));
6151 storeLE( mkexpr(addr), mkexpr(tmpRes) );
6214 putIReg(4, R_ESP, mkexpr(t_esp));
6216 storeLE( mkexpr(t_esp), getIReg(sz, eregOfRM(modrm)) );
6219 assign( t_addr0, mkexpr(t_esp) );
6224 mkexpr(t_bitno0),
6230 assign( t_bitno1, mkexpr(t_bitno0) );
6241 mkexpr(t_addr0),
6242 binop(Iop_Sar32, mkexpr(t_bitno1), mkU8(3))) );
6248 binop(Iop_And32, mkexpr(t_bitno1), mkU32(7))) );
6254 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
6259 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
6265 binop(Iop_Or8, mkexpr(t_fetched), mkexpr(t_mask)) );
6269 binop(Iop_Xor8, mkexpr(t_fetched), mkexpr(t_mask)) );
6273 binop(Iop_And8, mkexpr(t_fetched),
6274 unop(Iop_Not8, mkexpr(t_mask))) );
6280 casLE( mkexpr(t_addr1), mkexpr(t_fetched)/*expd*/,
6281 mkexpr(t_new)/*new*/,
6284 storeLE( mkexpr(t_addr1), mkexpr(t_new) );
6296 unop(Iop_8Uto32, mkexpr(t_fetched)),
6297 mkexpr(t_bitno2)),
6307 putIReg(sz, eregOfRM(modrm), loadLE(szToITy(sz), mkexpr(t_esp)) );
6308 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t_esp), mkU32(128)) );
6348 assign( src, loadLE(ty, mkexpr(addr)) );
6360 mkexpr(src), mkU(ty,0))) );
6368 IRExpr_Mux0X( mkexpr(src8),
6398 assign( src32, unop(Iop_16Uto32, mkexpr(src)) );
6400 assign( src32, mkexpr(src) );
6405 mkexpr(src8),
6409 fwds ? unop(Iop_Ctz32, mkexpr(src32))
6412 unop(Iop_Clz32, mkexpr(src32)))
6417 assign( dst, unop(Iop_32to16, mkexpr(dst32)) );
6419 assign( dst, mkexpr(dst32) );
6422 putIReg( sz, gregOfRM(modrm), mkexpr(dst) );
6437 putIReg( sz, R_EAX, mkexpr(t2) );
6438 putIReg( sz, reg, mkexpr(t1) );
6461 binop(Iop_And32, mkexpr(oldflags), mkU32(X86G_CC_MASK_O)),
6489 = binop(Iop_Or32, binop(Iop_And32, mkexpr(flags), mkU32(mask_SZACP)),
6535 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
6536 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
6537 putIReg(size, R_EAX, mkexpr(acc2));
6538 putIReg(size, eregOfRM(rm), mkexpr(dest2));
6546 assign( dest, loadLE(ty, mkexpr(addr)) );
6552 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
6553 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
6554 putIReg(size, R_EAX, mkexpr(acc2));
6555 storeLE( mkexpr(addr), mkexpr(dest2) );
6570 mkIRCAS( IRTemp_INVALID, dest, Iend_LE, mkexpr(addr),
6571 NULL, mkexpr(acc), NULL, mkexpr(src) )
6575 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
6576 putIReg(size, R_EAX, mkexpr(acc2));
6624 mkexpr(tmpd),
6625 mkexpr(tmps) )
6637 assign( tmps, loadLE(ty, mkexpr(addr)) );
6643 mkexpr(tmpd),
6644 mkexpr(tmps) )
6685 mkexpr(tmpd), mkexpr(tmpt0)) );
6687 putIReg(sz, eregOfRM(rm), mkexpr(tmpt1));
6688 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6698 assign( tmpd, loadLE(ty, mkexpr(addr)) );
6701 mkexpr(tmpd), mkexpr(tmpt0)) );
6702 storeLE( mkexpr(addr), mkexpr(tmpt1) );
6704 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6713 assign( tmpd, loadLE(ty, mkexpr(addr)) );
6716 mkexpr(tmpd), mkexpr(tmpt0)) );
6717 casLE( mkexpr(addr), mkexpr(tmpd)/*expVal*/,
6718 mkexpr(tmpt1)/*newVal*/, guest_EIP_curr_instr );
6720 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6746 putSReg( gregOfRM(rm), loadLE(Ity_I16, mkexpr(addr)) );
6777 storeLE( mkexpr(addr), getSReg(gregOfRM(rm)) );
6793 putIReg(4, R_ESP, mkexpr(ta));
6794 storeLE( mkexpr(ta), mkexpr(t1) );
6807 assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
6809 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(ta), mkU32(sz)) );
6810 putSReg( sreg, mkexpr(t1) );
6819 assign(t2, loadLE(Ity_I32,mkexpr(t1)));
6820 putIReg(4, R_ESP,binop(Iop_Add32, mkexpr(t1), mkU32(4+d32)));
6857 loadLE(Ity_V128, mkexpr(addr))) );
6908 loadLE(Ity_I32, mkexpr(addr))) );
6910 binop(op, gpart, mkexpr(epart)) );
6943 loadLE(Ity_I64, mkexpr(addr))) );
6945 binop(op, gpart, mkexpr(epart)) );
6975 unop(op, loadLE(Ity_V128, mkexpr(addr))) );
7005 mkexpr(oldG0),
7007 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7016 mkexpr(oldG0),
7017 loadLE(Ity_I32, mkexpr(addr)) ));
7018 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7048 mkexpr(oldG0),
7050 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7059 mkexpr(oldG0),
7060 loadLE(Ity_I64, mkexpr(addr)) ));
7061 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7094 epart = loadLE(Ity_V128, mkexpr(addr));
7191 all_lanes ? loadLE(Ity_V128, mkexpr(addr))
7192 : sz == 8 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
7193 : /*sz==4*/ unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr)))
7205 unop(Iop_NotV128, mkexpr(plain)) );
7211 binop(Iop_XorV128, mkexpr(plain), mkV128(mask)) );
7214 putXMMReg( gregOfRM(rm), mkexpr(plain) );
7244 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
7251 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
7271 unop(Iop_1Uto8,binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size))),
7273 binop(op, mkexpr(g0), mkexpr(amt8))
7281 unop(Iop_1Uto8,binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size))),
7282 binop(op, mkexpr(g0), mkU8(size-1)),
7283 binop(op, mkexpr(g0), mkexpr(amt8))
7291 putXMMReg( gregOfRM(rm), mkexpr(g1) );
7333 : binop(op, mkexpr(e0), mkU8(amt))
7338 ? binop(op, mkexpr(e0), mkU8(size-1))
7339 : binop(op, mkexpr(e0), mkU8(amt))
7346 putXMMReg( eregOfRM(rm), mkexpr(e1) );
7375 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
7376 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
7387 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
7388 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
7389 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
7390 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
7400 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
7401 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
7414 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
7415 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
7426 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
7427 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
7428 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
7429 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
7439 binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)),
7440 binop(Iop_16HLto32, mkexpr(t1), mkexpr(t0))
7470 mkexpr(t1),
7488 binop(Iop_Shr32, mkexpr(t1), mkU8(10)),
7500 binop(Iop_Shr32, mkexpr(t1), mkU8(21)),
7513 binop(Iop_Shr32, mkexpr(t1), mkU8(18)),
7524 binop(Iop_And32, mkexpr(t1), mkU32(1<<18)),
7554 binop(Iop_InterleaveHI16x4, mkexpr(aa), mkexpr(aa)),
7558 binop(Iop_InterleaveLO16x4, mkexpr(aa), mkexpr(aa)),
7562 binop(Iop_InterleaveHI16x4, mkexpr(bb), mkexpr(bb)),
7566 binop(Iop_InterleaveLO16x4, mkexpr(bb), mkexpr(bb)),
7577 binop(Iop_Mul32x2, mkexpr(aahi32s), mkexpr(bbhi32s)),
7580 mkexpr(one32x2)
7593 binop(Iop_Mul32x2, mkexpr(aalo32s), mkexpr(bblo32s)),
7596 mkexpr(one32x2)
7602 binop(Iop_CatEvenLanes16x4, mkexpr(rHi), mkexpr(rLo));
7633 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
7634 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
7635 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
7639 binop(Iop_And64, mkexpr(bb), mkexpr(posMask)),
7640 binop(Iop_And64, mkexpr(bbNeg), mkexpr(negMask)) );
7671 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
7672 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
7674 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
7677 binop(Iop_And64, mkexpr(aa), mkexpr(posMask)),
7678 binop(Iop_And64, mkexpr(aaNeg), mkexpr(negMask)) );
7687 binop(Iop_Shl64, mkexpr(hi64), mkU8(8*(8-byteShift))),
7688 binop(Iop_Shr64, mkexpr(lo64), mkU8(8*byteShift))
7705 binop(Iop_And32,mkexpr(effective_addr),mkU32(0x0)),
7955 putIReg(4, R_ESP, mkexpr(t2));
7956 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta));
8111 mkIRExprVec_1( mkexpr(addr) )
8117 d->mAddr = mkexpr(addr);
8181 mkIRExprVec_1( mkexpr(addr) )
8187 d->mAddr = mkexpr(addr);
8293 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
8306 unop(Iop_F32toF64,mkexpr(argL)),
8307 unop(Iop_F32toF64,mkexpr(argR))),
8332 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
8343 mkexpr(rmode),
8345 unop(Iop_64to32, mkexpr(arg64)) )) );
8350 mkexpr(rmode),
8352 unop(Iop_64HIto32, mkexpr(arg64)) )) );
8372 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
8383 mkexpr(rmode),
8384 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
8412 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8414 mkexpr(addr),
8432 mkexpr(rmode),
8433 unop( Iop_F32toF64, mkexpr(f32hi) ) ),
8435 mkexpr(rmode),
8436 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8440 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
8464 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8479 mkexpr(rmode),
8480 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8526 mkIRExprVec_1( loadLE(Ity_I32, mkexpr(addr)) )
8530 put_sse_roundingmode( unop(Iop_64to32, mkexpr(t64)) );
8531 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
8532 put_emwarn( mkexpr(ew) );
8538 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
8597 loadLE(Ity_V128, mkexpr(addr)) );
8616 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
8638 loadLE(Ity_I64, mkexpr(addr)) );
8651 storeLE( mkexpr(addr),
8676 loadLE(Ity_I64, mkexpr(addr)) );
8689 storeLE( mkexpr(addr),
8725 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
8726 binop(Iop_Or32, mkexpr(t2), mkexpr(t3))
8743 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
8764 storeLE( mkexpr(addr), getMMXReg(gregOfRM(modrm)) );
8792 loadLE(Ity_I32, mkexpr(addr)) );
8809 storeLE( mkexpr(addr),
8867 case 0: assign(t5, mkexpr(t0)); break;
8868 case 1: assign(t5, mkexpr(t1)); break;
8869 case 2: assign(t5, mkexpr(t2)); break;
8870 case 3: assign(t5, mkexpr(t3)); break;
8873 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t5)));
8911 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
8924 putMMXReg(gregOfRM(modrm), mkexpr(t6));
8979 mkIRExprVec_1(mkexpr(t0))));
8980 putIReg(4, gregOfRM(modrm), mkexpr(t1));
9076 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
9091 putMMXReg(gregOfRM(modrm), mkexpr(dV));
9160 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9216 storeLE( mkexpr(addr),
9260 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9351 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
9363 binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)),
9386 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9394 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)))
9399 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)))
9419 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9429 mkexpr(rmode), \
9430 unop(Iop_I32StoF64,mkexpr(_t)))
9457 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9467 unop(Iop_V128to64, mkexpr(argV))) );
9469 unop(Iop_V128HIto64, mkexpr(argV))) );
9472 mkexpr(rmode), \
9473 mkexpr(_t) )
9508 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9510 mkexpr(addr),
9527 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64hi) ),
9528 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo) )
9532 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
9553 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9563 unop(Iop_V128to64, mkexpr(argV))) );
9565 unop(Iop_V128HIto64, mkexpr(argV))) );
9568 mkexpr(rmode), \
9569 mkexpr(_t) )
9601 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9609 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)) )
9614 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)) )
9634 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9647 mkexpr(rmode), \
9649 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
9676 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
9678 binop(Iop_Add32,mkexpr(addr),mkU32(4))) );
9685 unop(Iop_F32toF64, mkexpr(f32hi)) );
9687 unop(Iop_F32toF64, mkexpr(f32lo)) );
9712 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9726 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo)) );
9746 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9755 binop( Iop_F64toF32, mkexpr(rmode), mkexpr(f64lo) )
9775 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
9783 unop(Iop_I32StoF64, mkexpr(arg32)) );
9802 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
9809 unop( Iop_F32toF64, mkexpr(f32lo) ) );
9828 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9839 unop(Iop_V128to64, mkexpr(argV))) );
9841 unop(Iop_V128HIto64, mkexpr(argV))) );
9844 mkexpr(rmode), \
9845 mkexpr(_t) )
9872 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9885 mkexpr(rmode), \
9887 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
9971 loadLE(Ity_V128, mkexpr(addr)) );
9991 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10015 unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)) )
10034 storeLE( mkexpr(addr),
10054 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10075 loadLE(Ity_V128, mkexpr(addr)) );
10098 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10132 loadLE(Ity_I64, mkexpr(addr)) );
10146 storeLE( mkexpr(addr),
10166 loadLE(Ity_I64, mkexpr(addr)) );
10180 storeLE( mkexpr(addr),
10207 binop(Iop_Or32, mkexpr(t0), mkexpr(t1))
10241 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
10245 mkexpr(regD),
10246 mkexpr(mask) ),
10248 mkexpr(olddata),
10249 unop(Iop_NotV128, mkexpr(mask)))) );
10250 storeLE( mkexpr(addr), mkexpr(newdata) );
10266 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10281 storeLE( mkexpr(addr), getIReg(4, gregOfRM(modrm)) );
10299 storeLE( mkexpr(addr),
10350 loadLE(Ity_I64, mkexpr(addr)) );
10371 storeLE( mkexpr(addr),
10421 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10429 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10430 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10431 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10432 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10434 # define SELD(n) mkexpr((n)==0 ? d0 : d1)
10435 # define SELS(n) mkexpr((n)==0 ? s0 : s1)
10499 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10506 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10507 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10508 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10509 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10513 binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
10516 binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
10692 case 0: assign(t4, unop(Iop_32to16, mkexpr(t0))); break;
10693 case 1: assign(t4, unop(Iop_32HIto16, mkexpr(t0))); break;
10694 case 2: assign(t4, unop(Iop_32to16, mkexpr(t1))); break;
10695 case 3: assign(t4, unop(Iop_32HIto16, mkexpr(t1))); break;
10696 case 4: assign(t4, unop(Iop_32to16, mkexpr(t2))); break;
10697 case 5: assign(t4, unop(Iop_32HIto16, mkexpr(t2))); break;
10698 case 6: assign(t4, unop(Iop_32to16, mkexpr(t3))); break;
10699 case 7: assign(t4, unop(Iop_32HIto16, mkexpr(t3))); break;
10702 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t4)));
10730 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
10736 putXMMRegLane16( gregOfRM(modrm), lane & 7, mkexpr(t4) );
10760 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
10766 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
10767 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
10768 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
10769 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
10774 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
10780 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
10782 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
10783 putXMMReg(gregOfRM(modrm), mkexpr(dV));
10832 mkIRExprVec_2( mkexpr(t1), mkexpr(t0) )));
10833 putIReg(4, gregOfRM(modrm), mkexpr(t5));
10883 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
10889 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
10890 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
10892 binop( Iop_MullU32, mkexpr(t0), mkexpr(t1) ) );
10919 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10928 assign( t0, binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) );
10929 putXMMRegLane64( gregOfRM(modrm), 0, mkexpr(t0) );
10930 assign( t1, binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)) );
10931 putXMMRegLane64( gregOfRM(modrm), 1, mkexpr(t1) );
10961 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
10967 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
10968 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
10969 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
10970 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
10975 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
10981 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
10983 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
10984 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11005 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11020 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11045 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11052 assign( sVhi, unop(Iop_V128HIto64, mkexpr(sV)) );
11062 mkexpr(dVhi),
11063 mkexpr(sV))) );
11064 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11089 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11096 assign( sVlo, unop(Iop_V128to64, mkexpr(sV)) );
11106 unop(Iop_V128HIto64, mkexpr(sV)),
11107 mkexpr(dVlo) ) );
11108 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11151 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11152 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11155 assign( lo64r, mkexpr(lo64) );
11156 assign( hi64r, mkexpr(hi64) );
11161 assign( hi64r, mkexpr(lo64) );
11167 mkexpr(lo64),
11171 mkexpr(lo64),
11175 binop(Iop_Shl64, mkexpr(hi64),
11177 binop(Iop_Shr64, mkexpr(lo64),
11182 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11183 putXMMReg(reg, mkexpr(dV));
11281 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11282 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11285 assign( lo64r, mkexpr(lo64) );
11286 assign( hi64r, mkexpr(hi64) );
11291 assign( lo64r, mkexpr(hi64) );
11297 mkexpr(hi64),
11301 mkexpr(hi64),
11305 binop(Iop_Shr64, mkexpr(lo64),
11307 binop(Iop_Shl64, mkexpr(hi64),
11313 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11314 putXMMReg(reg, mkexpr(dV));
11516 mkexpr(addr),
11569 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11595 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
11598 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
11604 putXMMReg( gregOfRM(modrm), binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
11625 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11633 assign( addV, binop(Iop_Add32Fx4, mkexpr(gV), mkexpr(eV)) );
11634 assign( subV, binop(Iop_Sub32Fx4, mkexpr(gV), mkexpr(eV)) );
11660 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11668 assign( addV, binop(Iop_Add64Fx2, mkexpr(gV), mkexpr(eV)) );
11669 assign( subV, binop(Iop_Sub64Fx2, mkexpr(gV), mkexpr(eV)) );
11671 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
11672 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
11675 binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
11700 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11716 mkexpr(leftV), mkexpr(rightV) ) );
11742 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11750 assign( e1, unop(Iop_V128HIto64, mkexpr(eV) ));
11751 assign( e0, unop(Iop_V128to64, mkexpr(eV) ));
11752 assign( g1, unop(Iop_V128HIto64, mkexpr(gV) ));
11753 assign( g0, unop(Iop_V128to64, mkexpr(gV) ));
11755 assign( leftV, binop(Iop_64HLtoV128, mkexpr(e0),mkexpr(g0)) );
11756 assign( rightV, binop(Iop_64HLtoV128, mkexpr(e1),mkexpr(g1)) );
11760 mkexpr(leftV), mkexpr(rightV) ) );
11772 loadLE(Ity_V128, mkexpr(addr)) );
11810 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
11818 binop(Iop_SarN16x4, mkexpr(sV), mkU8(8)) );
11821 binop(Iop_ShlN16x4, mkexpr(sV), mkU8(8)),
11824 binop(Iop_ShrN16x4, mkexpr(dV), mkU8(8)) );
11827 binop(Iop_ShlN16x4, mkexpr(dV), mkU8(8)),
11833 binop(Iop_Mul16x4, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
11834 binop(Iop_Mul16x4, mkexpr(sVevensSX), mkexpr(dVevensZX))
11862 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11870 binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
11873 binop(Iop_ShlN16x8, mkexpr(sV), mkU8(8)),
11876 binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
11879 binop(Iop_ShlN16x8, mkexpr(dV), mkU8(8)),
11885 binop(Iop_Mul16x8, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
11886 binop(Iop_Mul16x8, mkexpr(sVevensSX), mkexpr(dVevensZX))
11943 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
11952 binop(opCatE,mkexpr(sV),mkexpr(dV)),
11953 binop(opCatO,mkexpr(sV),mkexpr(dV))
12013 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12019 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12020 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12021 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12022 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12031 binop(opCatE,mkexpr(sHi),mkexpr(sLo)),
12032 binop(opCatO,mkexpr(sHi),mkexpr(sLo))
12035 binop(opCatE,mkexpr(dHi),mkexpr(dLo)),
12036 binop(opCatO,mkexpr(dHi),mkexpr(dLo))
12061 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12069 dis_PMULHRSW_helper( mkexpr(sV), mkexpr(dV) )
12096 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12102 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12103 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12104 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12105 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12110 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
12111 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
12146 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12154 dis_PSIGN_helper( mkexpr(sV), mkexpr(dV), laneszB )
12192 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12198 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12199 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12200 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12201 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12206 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
12207 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
12240 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12248 dis_PABS_helper( mkexpr(sV), laneszB )
12282 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12288 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12289 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12294 dis_PABS_helper( mkexpr(sHi), laneszB ),
12295 dis_PABS_helper( mkexpr(sLo), laneszB )
12321 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12330 assign( res, mkexpr(sV) );
12335 binop(Iop_Shr64, mkexpr(sV), mkU8(8*d32)),
12336 binop(Iop_Shl64, mkexpr(dV), mkU8(8*(8-d32))
12340 assign( res, mkexpr(dV) );
12343 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d32-8))) );
12351 putMMXReg( gregOfRM(modrm), mkexpr(res) );
12380 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12388 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12389 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12390 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12391 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12394 assign( rHi, mkexpr(sHi) );
12395 assign( rLo, mkexpr(sLo) );
12402 assign( rHi, mkexpr(dLo) );
12403 assign( rLo, mkexpr(sHi) );
12410 assign( rHi, mkexpr(dHi) );
12411 assign( rLo, mkexpr(dLo) );
12414 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-16))) );
12419 assign( rLo, mkexpr(dHi) );
12423 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-24))) );
12434 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12456 mkexpr(addr)) );
12469 mkexpr(dV),
12470 binop(Iop_And64, mkexpr(sV), mkU64(0x0707070707070707ULL))
12473 unop(Iop_Not64, binop(Iop_SarN8x8, mkexpr(sV), mkU8(7)))
12511 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12517 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12518 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12519 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12520 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12534 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sHi),mkU8(7))));
12539 binop(Iop_ShlN8x8,mkexpr(sHi),mkU8(4)),
12542 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
12549 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7hi)),
12550 mkexpr(maskBit3hi)),
12552 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7hi)),
12553 unop(Iop_Not64,mkexpr(maskBit3hi))) ));
12555 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
12561 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sLo),mkU8(7))));
12566 binop(Iop_ShlN8x8,mkexpr(sLo),mkU8(4)),
12569 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
12576 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7lo)),
12577 mkexpr(maskBit3lo)),
12579 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7lo)),
12580 unop(Iop_Not64,mkexpr(maskBit3lo))) ));
12582 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
12586 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12629 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
12642 mkU32(imm & 3), mkexpr(src)) );
12645 putXMMRegLane64F( gregOfRM(modrm), 0, mkexpr(res) );
12647 putXMMRegLane32F( gregOfRM(modrm), 0, mkexpr(res) );
12670 assign(src, loadLE(ty, mkexpr(addr)));
12677 putIReg(sz, gregOfRM(modrm), mkexpr(res));
12685 assign(src32, widenUto32(mkexpr(src)));
12686 assign(res32, widenUto32(mkexpr(res)));
12694 binop(Iop_CmpEQ32, mkexpr(res32), mkU32(0))),
12698 binop(Iop_CmpEQ32, mkexpr(src32), mkU32(0))),
12706 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
12772 assign(t2, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(0) )));
12773 assign(t3, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(4) )));
12774 assign(t4, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(8) )));
12776 putIReg(4, R_ESP,binop(Iop_Add32, mkexpr(t1), mkU32(12)));
12778 putSReg( R_CS, unop(Iop_32to16, mkexpr(t3)) );
12808 putIReg(4, R_ESP, mkexpr(t1));
12809 storeLE( mkexpr(t1), mkU32(guest_EIP_bbstart+delta));
12851 putIReg(4, R_ESP, mkexpr(t1));
12852 assign(t2, loadLE(Ity_I32,mkexpr(t1)));
12853 putIReg(4, R_EBP, mkexpr(t2));
12854 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(4)) );
12887 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
12889 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
12895 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
12937 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
12939 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
12945 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
13034 putIReg(sz, (UInt)(opc - 0x40), mkexpr(t1));
13053 putIReg(sz, (UInt)(opc - 0x48), mkexpr(t1));
13310 putIReg(sz, gregOfRM(modrm), mkexpr(addr));
13331 putIReg(sz, R_EAX, loadLE(ty, mkexpr(addr)));
13344 storeLE( mkexpr(addr), getIReg(sz,R_EAX) );
13393 storeLE(mkexpr(addr), mkU(szToITy(sz), d32));
13615 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
13616 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13617 putIReg(sz, opc-0x58, mkexpr(t1));
13625 assign(t1, widenUto32(loadLE(szToITy(sz),mkexpr(t2))));
13626 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13645 putIReg(4,R_EAX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(28)) ));
13646 putIReg(4,R_ECX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(24)) ));
13647 putIReg(4,R_EDX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(20)) ));
13648 putIReg(4,R_EBX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(16)) ));
13650 putIReg(4,R_EBP, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 8)) ));
13651 putIReg(4,R_ESI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 4)) ));
13652 putIReg(4,R_EDI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 0)) ));
13655 putIReg( 4, R_ESP, binop(Iop_Add32, mkexpr(t5), mkU32(8*4)) );
13677 assign( t3, loadLE(ty, mkexpr(t1)) );
13685 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(sz)) );
13689 storeLE( mkexpr(addr), mkexpr(t3) );
13722 putIReg(4, R_ESP, mkexpr(t2) );
13723 storeLE(mkexpr(t2),mkexpr(t1));
13738 putIReg(4, R_ESP, mkexpr(t1) );
13743 storeLE( mkexpr(t1), mkU(ty,d32) );
13752 putIReg(4, R_ESP, mkexpr(t1) );
13768 mkexpr(t2),
13777 mkexpr(t3),
13787 mkexpr(t4),
13796 storeLE( mkexpr(t1), unop(Iop_32to16,mkexpr(t5)) );
13798 storeLE( mkexpr(t1), mkexpr(t5) );
13818 assign( t5, binop(Iop_Sub32, mkexpr(t0), mkU32(8*4)) );
13821 putIReg(4, R_ESP, mkexpr(t5));
13824 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(28)), getIReg(4,R_EAX) );
13825 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(24)), getIReg(4,R_ECX) );
13826 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(20)), getIReg(4,R_EDX) );
13827 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(16)), getIReg(4,R_EBX) );
13828 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(12)), mkexpr(t0) /*esp*/);
13829 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 8)), getIReg(4,R_EBP) );
13830 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 4)), getIReg(4,R_ESI) );
13831 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 0)), getIReg(4,R_EDI) );
13901 assign( t1, binop(Iop_And32, mkexpr(t0),
13906 assign( t1, binop(Iop_Or32, mkexpr(t0),
13911 assign( t1, binop(Iop_Xor32, mkexpr(t0),
13920 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t1) ));
13933 binop(Iop_Shl32, mkexpr(t0), mkU8(31)),
13935 putIReg(1, R_EAX, unop(Iop_32to8, mkexpr(t1)) );
14058 putIReg(sz, gregOfRM(modrm), mkexpr(t1));
14059 putIReg(sz, eregOfRM(modrm), mkexpr(t2));
14067 assign( t1, loadLE(ty,mkexpr(addr)) );
14069 casLE( mkexpr(addr),
14070 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
14071 putIReg( sz, gregOfRM(modrm), mkexpr(t1) );
14150 mkIRExprVec_2( mkexpr(t1), mkU32(sz) )
14154 putIReg(sz, R_EAX, narrowTo( ty, mkexpr(t2) ) );
14196 mkIRExprVec_3( mkexpr(t1),
14394 binop(Iop_Shl32, mkexpr(t1), mkU8(24)),
14396 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t1), mkU8(8)),
14399 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(8)),
14401 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(24)),
14406 putIReg(4, opc-0xC8, mkexpr(t2));
14489 Iend_LE, mkexpr(addr),
14490 mkexpr(expdHi), mkexpr(expdLo),
14491 mkexpr(dataHi), mkexpr(dataLo)
14498 binop(Iop_Xor32, mkexpr(oldHi), mkexpr(expdHi)),
14499 binop(Iop_Xor32, mkexpr(oldLo), mkexpr(expdLo))
14511 IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(success)),
14512 mkexpr(oldHi),
14513 mkexpr(expdHi)
14516 IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(success)),
14517 mkexpr(oldLo),
14518 mkexpr(expdLo)
14527 binop(Iop_And32, mkexpr(flags_old),
14531 unop(Iop_1Uto32, mkexpr(success)), mkU32(1)),
14535 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(flags_new) ));
14787 putIReg(4, R_EDX, unop(Iop_64HIto32, mkexpr(val)));
14788 putIReg(4, R_EAX, unop(Iop_64to32, mkexpr(val)));
14827 putIReg(1, eregOfRM(modrm), mkexpr(t1));
14833 storeLE( mkexpr(addr), mkexpr(t1) );
15033 mkIRExprVec_2( mkexpr(addr),
15038 d->mAddr = mkexpr(addr);
