Lines Matching defs:mkexpr
658 static IRExpr* mkexpr ( IRTemp tmp )
763 NULL, mkexpr(expTmp), NULL, newVal );
767 mkexpr(oldTmp), mkexpr(expTmp) ),
927 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(dep1))) );
928 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(mkexpr(dep2))) );
952 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(dep1))) );
987 assign( guardB, binop(Iop_CmpNE8, mkexpr(guard), mkU8(0)) );
991 IRExpr_ITE( mkexpr(guardB),
995 IRExpr_ITE( mkexpr(guardB),
996 widenUto32(mkexpr(res)),
999 IRExpr_ITE( mkexpr(guardB),
1000 widenUto32(mkexpr(resUS)),
1005 IRExpr_ITE( mkexpr(guardB),
1026 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(res))) );
1050 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(arg1)) ));
1051 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(mkexpr(arg2)) ));
1145 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1148 binop(plus,mkexpr(ta1),mkexpr(ta2)),
1149 mkexpr(oldcn)) );
1156 storeLE( mkexpr(taddr), mkexpr(tres) );
1160 casLE( mkexpr(taddr),
1161 mkexpr(texpVal), mkexpr(tres), restart_point );
1166 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(ta1)) ));
1167 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(binop(xor, mkexpr(ta2),
1168 mkexpr(oldcn)) )) );
1169 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
1199 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1202 binop(minus,mkexpr(ta1),mkexpr(ta2)),
1203 mkexpr(oldcn)) );
1210 storeLE( mkexpr(taddr), mkexpr(tres) );
1214 casLE( mkexpr(taddr),
1215 mkexpr(texpVal), mkexpr(tres), restart_point );
1220 stmt( IRStmt_Put( OFFB_CC_DEP1, widenUto32(mkexpr(ta1) )) );
1221 stmt( IRStmt_Put( OFFB_CC_DEP2, widenUto32(binop(xor, mkexpr(ta2),
1222 mkexpr(oldcn)) )) );
1223 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(oldc) ) );
1367 stmt( IRStmt_Put( OFFB_EIP, mkexpr(t) ) );
1462 mkIRExprVec_4( mkexpr(ldt_ptr), mkexpr(gdt_ptr),
1463 mkexpr(seg_selector), virtual)
1473 binop(Iop_CmpNE32, unop(Iop_64HIto32, mkexpr(r64)), mkU32(0)),
1481 return unop(Iop_64to32, mkexpr(r64));
1863 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1868 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1870 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
1876 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1887 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
1892 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1897 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1899 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
1905 putIReg(size, gregOfRM(rm), mkexpr(dst1));
1976 putIReg(size, eregOfRM(rm), mkexpr(dst1));
1981 putIReg(size, eregOfRM(rm), mkexpr(dst1));
1983 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
1989 putIReg(size, eregOfRM(rm), mkexpr(dst1));
2001 assign(dst0, loadLE(ty,mkexpr(addr)));
2026 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2030 casLE( mkexpr(addr),
2031 mkexpr(dst0)/*expval*/,
2032 mkexpr(dst1)/*newval*/, guest_EIP_curr_instr );
2035 storeLE(mkexpr(addr), mkexpr(dst1));
2087 putIReg(size, gregOfRM(rm), loadLE(szToITy(size), mkexpr(addr)));
2131 storeLE( mkexpr(addr), getIReg(size, gregOfRM(rm)) );
2157 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2163 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2180 putIReg(size, R_EAX, mkexpr(dst1));
2220 loadLE(szToITy(szs),mkexpr(addr)));
2225 loadLE(szToITy(szs),mkexpr(addr))));
2247 assign( dst64, binop(op, mkexpr(src64), mkexpr(t)) );
2248 putIReg( 4, R_EAX, unop(Iop_64to32,mkexpr(dst64)) );
2249 putIReg( 4, R_EDX, unop(Iop_64HIto32,mkexpr(dst64)) );
2257 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
2258 putIReg( 2, R_EAX, unop(Iop_32to16,unop(Iop_64to32,mkexpr(dst64))) );
2259 putIReg( 2, R_EDX, unop(Iop_32to16,unop(Iop_64HIto32,mkexpr(dst64))) );
2268 binop(op, mkexpr(src64),
2269 unop(widen1632, unop(widen816, mkexpr(t)))) );
2271 unop(Iop_64to32,mkexpr(dst64)))) );
2273 unop(Iop_64HIto32,mkexpr(dst64)))) );
2320 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2328 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2336 assign(dst0, loadLE(ty,mkexpr(addr)));
2361 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2364 casLE( mkexpr(addr), mkexpr(dst0)/*expVal*/,
2365 mkexpr(dst1)/*newVal*/,
2368 storeLE(mkexpr(addr), mkexpr(dst1));
2413 assign(dst0, loadLE(ty,mkexpr(addr)));
2437 = mkIRExprVec_4( widenUto32(mkexpr(dst0)), /* thing to rotate */
2450 assign( dst1, narrowTo(ty, unop(Iop_64to32, mkexpr(r64))) );
2452 stmt( IRStmt_Put( OFFB_CC_DEP1, unop(Iop_64HIto32, mkexpr(r64)) ));
2490 assign( pre32, op32==Iop_Sar32 ? widenSto32(mkexpr(dst0))
2491 : widenUto32(mkexpr(dst0)) );
2494 assign( res32, binop(op32, mkexpr(pre32), mkexpr(shift_amt)) );
2499 mkexpr(pre32),
2502 mkexpr(shift_amt), mkU8(1)),
2509 assign( dst1, narrowTo(ty, mkexpr(res32)) );
2528 assign(rot_amt, mkexpr(rot_amt32));
2530 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt32), mkU8(8*sz-1)));
2538 mkexpr(dst0),
2539 mkexpr(rot_amt)
2542 mkexpr(dst0),
2543 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
2555 mkexpr(dst0),
2556 mkexpr(rot_amt)
2559 mkexpr(dst0),
2560 binop(Iop_Sub8,mkU8(8*sz), mkexpr(rot_amt))
2576 assign(rot_amt32b, binop(Iop_CmpNE8, mkexpr(rot_amt32), mkU8(0)) );
2580 IRExpr_ITE( mkexpr(rot_amt32b),
2584 IRExpr_ITE( mkexpr(rot_amt32b),
2585 widenUto32(mkexpr(dst1)),
2588 IRExpr_ITE( mkexpr(rot_amt32b),
2592 IRExpr_ITE( mkexpr(rot_amt32b),
2593 mkexpr(oldFlags),
2599 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2610 storeLE(mkexpr(addr), mkexpr(dst1));
2680 assign( t2, widenUto32(loadLE(ty, mkexpr(t_addr))) );
2690 assign( t2m, binop(Iop_Or32, mkU32(mask), mkexpr(t2)) );
2693 assign( t2m, binop(Iop_And32, mkU32(mask), mkexpr(t2)) );
2696 assign( t2m, binop(Iop_Xor32, mkU32(mask), mkexpr(t2)) );
2708 putIReg(sz, eregOfRM(modrm), narrowTo(ty, mkexpr(t2m)));
2711 casLE( mkexpr(t_addr),
2712 narrowTo(ty, mkexpr(t2))/*expd*/,
2713 narrowTo(ty, mkexpr(t2m))/*new*/,
2716 storeLE(mkexpr(t_addr), narrowTo(ty, mkexpr(t2m)));
2728 binop(Iop_Shr32, mkexpr(t2), mkU8(src_val)),
2759 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2760 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
2761 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
2762 putIReg(4, R_EDX, mkexpr(resHi));
2763 putIReg(4, R_EAX, mkexpr(resLo));
2773 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2774 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
2775 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
2776 putIReg(2, R_EDX, mkexpr(resHi));
2777 putIReg(2, R_EAX, mkexpr(resLo));
2787 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
2788 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
2789 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
2790 putIReg(2, R_EAX, mkexpr(res16));
2857 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0), mkexpr(src)));
2859 putIReg(sz, eregOfRM(modrm), mkexpr(dst1));
2894 assign(t1, loadLE(ty,mkexpr(addr)));
2900 mkexpr(t1), mkU(ty,d32)));
2911 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
2913 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
2916 storeLE( mkexpr(addr), mkexpr(dst1) );
2925 assign(src, mkexpr(t1));
2927 mkexpr(dst0), mkexpr(src)));
2929 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(dst1)/*new*/,
2932 storeLE( mkexpr(addr), mkexpr(dst1) );
2985 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
2986 putIReg(1, eregOfRM(modrm), mkexpr(t2));
2990 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
2991 putIReg(1, eregOfRM(modrm), mkexpr(t2));
3003 assign( t1, loadLE(ty, mkexpr(addr)) );
3006 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
3008 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
3011 storeLE( mkexpr(addr), mkexpr(t2) );
3016 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
3018 casLE( mkexpr(addr), mkexpr(t1)/*expd*/, mkexpr(t2)/*new*/,
3021 storeLE( mkexpr(addr), mkexpr(t2) );
3066 mkexpr(t1), mkU(ty,1)));
3068 putIReg(sz,eregOfRM(modrm),mkexpr(t2));
3074 mkexpr(t1), mkU(ty,1)));
3076 putIReg(sz,eregOfRM(modrm),mkexpr(t2));
3082 putIReg(4, R_ESP, mkexpr(t2));
3083 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta+1));
3096 putIReg(4, R_ESP, mkexpr(t2) );
3097 storeLE( mkexpr(t2), mkexpr(t1) );
3108 assign(t1, loadLE(ty,mkexpr(addr)));
3113 mkexpr(t1), mkU(ty,1)));
3115 casLE( mkexpr(addr),
3116 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
3118 storeLE(mkexpr(addr),mkexpr(t2));
3125 mkexpr(t1), mkU(ty,1)));
3127 casLE( mkexpr(addr),
3128 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
3130 storeLE(mkexpr(addr),mkexpr(t2));
3138 putIReg(4, R_ESP, mkexpr(t2));
3139 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta+len));
3152 putIReg(4, R_ESP, mkexpr(t2) );
3153 storeLE( mkexpr(t2), mkexpr(t1) );
3206 storeLE( mkexpr(td), loadLE(ty,mkexpr(ts)) );
3208 putIReg( 4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3209 putIReg( 4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3220 putIReg( sz, R_EAX, loadLE(ty, mkexpr(ts)) );
3222 putIReg( 4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3235 storeLE( mkexpr(td), mkexpr(ta) );
3237 putIReg( 4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3252 assign( tdv, loadLE(ty,mkexpr(td)) );
3253 assign( tsv, loadLE(ty,mkexpr(ts)) );
3257 putIReg(4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3258 putIReg(4, R_ESI, binop(Iop_Add32, mkexpr(ts), mkexpr(t_inc)) );
3272 assign( tdv, loadLE(ty,mkexpr(td)) );
3275 putIReg(4, R_EDI, binop(Iop_Add32, mkexpr(td), mkexpr(t_inc)) );
3293 stmt( IRStmt_Exit( binop(Iop_CmpEQ32,mkexpr(tc),mkU32(0)),
3297 putIReg(4, R_ECX, binop(Iop_Sub32, mkexpr(tc), mkU32(1)) );
3339 assign( te, loadLE(ty,mkexpr(addr)) );
3344 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
3346 putIReg(size, gregOfRM(rm), mkexpr(resLo) );
3383 assign(te, loadLE(ty, mkexpr(addr)));
3394 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
3398 putIReg(size, gregOfRM(rm), mkexpr(resLo));
3417 assign(src32, widenUto32( mkexpr(src) ));
3421 binop(Iop_Shl32, mkexpr(src32),
3429 binop(Iop_CmpEQ32, mkexpr(src32x), mkU32(0)),
3431 unop(Iop_Clz32, mkexpr(src32x))
3435 assign(res, narrowTo(ty, mkexpr(res32)));
3618 IRExpr_ITE(mkexpr(cond), mkU8(1)/*FULL*/, mkexpr(old_tag)));
3624 IRExpr_ITE(mkexpr(cond),
3625 IRExpr_ITE(binop(Iop_CmpNE8, mkexpr(old_tag), mkU8(0)),
3630 mkexpr(old_val)));
3632 put_ST_UNCHECKED(i, mkexpr(new_val));
3635 put_ST_TAG(i, mkexpr(new_tag));
3650 put_ftop( binop(Iop_Sub32, get_ftop(), unop(Iop_1Uto32,mkexpr(cond))) );
3695 assign(i64, unop(Iop_ReinterpF64asI64, mkexpr(d64)) );
3699 binop(Iop_Shr32, unop(Iop_64HIto32, mkexpr(i64)), mkU8(20)),
3703 binop(Iop_CmpLE32U, mkexpr(exponent), mkU32(0x43D)));
3741 loadLE(Ity_F64,mkexpr(addr))
3748 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr)))
3766 loadLE(Ity_F64,mkexpr(addr)),
3773 unop(Iop_F32toF64, loadLE(Ity_F32,mkexpr(addr))),
3887 loadLE(Ity_F32,mkexpr(addr)))),
3902 loadLE(Ity_F32,mkexpr(addr)))),
4009 loadLE(Ity_F32, mkexpr(addr))));
4014 storeLE(mkexpr(addr),
4020 storeLE(mkexpr(addr),
4033 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
4038 d->mAddr = mkexpr(addr);
4067 put_emwarn( mkexpr(ew) );
4070 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
4100 loadLE(Ity_I16, mkexpr(addr)))
4105 put_fpround( unop(Iop_64to32, mkexpr(t64)) );
4106 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
4107 put_emwarn( mkexpr(ew) );
4113 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
4129 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
4133 d->mAddr = mkexpr(addr);
4169 mkexpr(addr),
4196 put_ST(0, mkexpr(t1));
4206 put_ST_UNCHECKED(0, mkexpr(t2));
4207 put_ST_UNCHECKED(r_src, mkexpr(t1));
4333 mkexpr(argOK),
4336 mkexpr(argD)),
4337 mkexpr(argD))
4339 put_ST_UNCHECKED(0, mkexpr(resD));
4346 unop(Iop_1Uto32, mkexpr(argOK)),
4370 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
4376 mkIRExprVec_2( mkexpr(argI),
4384 mkIRExprVec_2( mkexpr(argI),
4387 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
4388 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
4390 put_ST_UNCHECKED(0, mkexpr(expF) );
4393 put_ST(0, mkexpr(sigF) );
4408 mkexpr(a1),
4409 mkexpr(a2)));
4413 mkexpr(a1),
4414 mkexpr(a2)) );
4434 mkexpr(a1),
4435 mkexpr(a2)));
4439 mkexpr(a1),
4440 mkexpr(a2)) );
4470 mkexpr(argOK),
4473 mkexpr(argD)),
4474 mkexpr(argD))
4476 put_ST_UNCHECKED(0, mkexpr(resD));
4483 mkexpr(argD)));
4485 unop(Iop_1Uto32, mkexpr(argOK)),
4515 mkexpr(argOK),
4518 mkexpr(argD)),
4519 mkexpr(argD))
4521 put_ST_UNCHECKED(0, mkexpr(resD));
4523 unop(Iop_1Uto32, mkexpr(argOK)),
4566 loadLE(Ity_I32,mkexpr(addr)))),
4581 loadLE(Ity_I32,mkexpr(addr)))),
4614 loadLE(Ity_I32, mkexpr(addr)))));
4622 loadLE(Ity_I32, mkexpr(addr))),
4710 loadLE(Ity_I32, mkexpr(addr))));
4715 storeLE( mkexpr(addr),
4722 storeLE( mkexpr(addr),
4728 storeLE( mkexpr(addr),
4739 IRExpr** args = mkIRExprVec_1 ( mkexpr(addr) );
4750 d->mAddr = mkexpr(addr);
4756 put_ST(0, unop(Iop_ReinterpI64asF64, mkexpr(val)));
4765 = mkIRExprVec_2( mkexpr(addr),
4776 d->mAddr = mkexpr(addr);
4920 loadLE(Ity_F64,mkexpr(addr))),
4934 loadLE(Ity_F64,mkexpr(addr))),
5015 put_ST(0, loadLE(Ity_F64, mkexpr(addr)));
5020 storeLE( mkexpr(addr),
5027 storeLE(mkexpr(addr), get_ST(0));
5032 storeLE(mkexpr(addr), get_ST(0));
5044 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
5049 d->mAddr = mkexpr(addr);
5082 put_emwarn( mkexpr(ew) );
5085 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
5103 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
5107 d->mAddr = mkexpr(addr);
5143 storeLE( mkexpr(addr), sw );
5249 loadLE(Ity_I16,mkexpr(addr))))),
5265 loadLE(Ity_I16,mkexpr(addr))))),
5299 loadLE(Ity_I16, mkexpr(addr))))));
5308 loadLE(Ity_I16, mkexpr(addr)))),
5386 loadLE(Ity_I16, mkexpr(addr)))));
5391 storeLE( mkexpr(addr),
5398 storeLE( mkexpr(addr),
5404 storeLE( mkexpr(addr),
5414 loadLE(Ity_I64, mkexpr(addr))));
5419 storeLE( mkexpr(addr),
5460 putIReg( 1, R_AL, unop(Iop_16to8, mkexpr(t16)) );
5461 putIReg( 1, R_AH, unop(Iop_16HIto8, mkexpr(t16)) );
5662 argE = loadLE(Ity_I64, mkexpr(addr));
5689 putMMXReg( gregOfRM(modrm), mkexpr(res) );
5724 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
5731 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
5751 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
5752 binop(op, mkexpr(g0), mkexpr(amt8)),
5761 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
5762 binop(op, mkexpr(g0), mkexpr(amt8)),
5763 binop(op, mkexpr(g0), mkU8(size-1))
5771 putMMXReg( gregOfRM(rm), mkexpr(g1) );
5815 : binop(op, mkexpr(e0), mkU8(amt))
5820 ? binop(op, mkexpr(e0), mkU8(size-1))
5821 : binop(op, mkexpr(e0), mkU8(amt))
5828 putMMXReg( eregOfRM(rm), mkexpr(e1) );
5870 loadLE(Ity_I32, mkexpr(addr)) ) );
5888 storeLE( mkexpr(addr),
5907 putMMXReg( gregOfRM(modrm), loadLE(Ity_I64, mkexpr(addr)) );
5926 storeLE( mkexpr(addr), getMMXReg(gregOfRM(modrm)) );
6142 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
6143 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
6147 mkexpr(regD),
6148 mkexpr(mask) ),
6150 mkexpr(olddata),
6151 unop(Iop_Not64, mkexpr(mask)))) );
6152 storeLE( mkexpr(addr), mkexpr(newdata) );
6232 assign( esrc, loadLE(ty, mkexpr(addr)) );
6266 assign( tmpL, binop(mkpair, mkexpr(esrc), mkexpr(gsrc)) );
6268 assign( tmpL, binop(mkpair, mkexpr(gsrc), mkexpr(esrc)) );
6270 assign( tmpRes, unop(getres, binop(shift, mkexpr(tmpL), mkexpr(tmpSH)) ) );
6274 mkexpr(tmpL),
6276 binop(Iop_Sub8, mkexpr(tmpSH), mkU8(1) ),
6285 putIReg(sz, eregOfRM(modrm), mkexpr(tmpRes));
6287 storeLE( mkexpr(addr), mkexpr(tmpRes) );
6350 putIReg(4, R_ESP, mkexpr(t_esp));
6352 storeLE( mkexpr(t_esp), getIReg(sz, eregOfRM(modrm)) );
6355 assign( t_addr0, mkexpr(t_esp) );
6360 mkexpr(t_bitno0),
6366 assign( t_bitno1, mkexpr(t_bitno0) );
6377 mkexpr(t_addr0),
6378 binop(Iop_Sar32, mkexpr(t_bitno1), mkU8(3))) );
6384 binop(Iop_And32, mkexpr(t_bitno1), mkU32(7))) );
6390 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
6395 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
6401 binop(Iop_Or8, mkexpr(t_fetched), mkexpr(t_mask)) );
6405 binop(Iop_Xor8, mkexpr(t_fetched), mkexpr(t_mask)) );
6409 binop(Iop_And8, mkexpr(t_fetched),
6410 unop(Iop_Not8, mkexpr(t_mask))) );
6416 casLE( mkexpr(t_addr1), mkexpr(t_fetched)/*expd*/,
6417 mkexpr(t_new)/*new*/,
6420 storeLE( mkexpr(t_addr1), mkexpr(t_new) );
6432 unop(Iop_8Uto32, mkexpr(t_fetched)),
6433 mkexpr(t_bitno2)),
6443 putIReg(sz, eregOfRM(modrm), loadLE(szToITy(sz), mkexpr(t_esp)) );
6444 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t_esp), mkU32(128)) );
6484 assign( src, loadLE(ty, mkexpr(addr)) );
6499 mkexpr(src), mkU(ty,0)) );
6507 IRExpr_ITE( mkexpr(srcB),
6537 assign( src32, unop(Iop_16Uto32, mkexpr(src)) );
6539 assign( src32, mkexpr(src) );
6544 mkexpr(srcB),
6546 fwds ? unop(Iop_Ctz32, mkexpr(src32))
6549 unop(Iop_Clz32, mkexpr(src32))),
6556 assign( dst, unop(Iop_32to16, mkexpr(dst32)) );
6558 assign( dst, mkexpr(dst32) );
6561 putIReg( sz, gregOfRM(modrm), mkexpr(dst) );
6576 putIReg( sz, R_EAX, mkexpr(t2) );
6577 putIReg( sz, reg, mkexpr(t1) );
6600 binop(Iop_And32, mkexpr(oldflags), mkU32(X86G_CC_MASK_O)),
6628 = binop(Iop_Or32, binop(Iop_And32, mkexpr(flags), mkU32(mask_SZACP)),
6674 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
6675 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
6676 putIReg(size, R_EAX, mkexpr(acc2));
6677 putIReg(size, eregOfRM(rm), mkexpr(dest2));
6685 assign( dest, loadLE(ty, mkexpr(addr)) );
6691 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
6692 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
6693 putIReg(size, R_EAX, mkexpr(acc2));
6694 storeLE( mkexpr(addr), mkexpr(dest2) );
6709 mkIRCAS( IRTemp_INVALID, dest, Iend_LE, mkexpr(addr),
6710 NULL, mkexpr(acc), NULL, mkexpr(src) )
6714 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
6715 putIReg(size, R_EAX, mkexpr(acc2));
6762 mkexpr(tmps),
6763 mkexpr(tmpd) )
6775 assign( tmps, loadLE(ty, mkexpr(addr)) );
6780 mkexpr(tmps),
6781 mkexpr(tmpd) )
6822 mkexpr(tmpd), mkexpr(tmpt0)) );
6824 putIReg(sz, eregOfRM(rm), mkexpr(tmpt1));
6825 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6835 assign( tmpd, loadLE(ty, mkexpr(addr)) );
6838 mkexpr(tmpd), mkexpr(tmpt0)) );
6839 storeLE( mkexpr(addr), mkexpr(tmpt1) );
6841 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6850 assign( tmpd, loadLE(ty, mkexpr(addr)) );
6853 mkexpr(tmpd), mkexpr(tmpt0)) );
6854 casLE( mkexpr(addr), mkexpr(tmpd)/*expVal*/,
6855 mkexpr(tmpt1)/*newVal*/, guest_EIP_curr_instr );
6857 putIReg(sz, gregOfRM(rm), mkexpr(tmpd));
6883 putSReg( gregOfRM(rm), loadLE(Ity_I16, mkexpr(addr)) );
6914 storeLE( mkexpr(addr), getSReg(gregOfRM(rm)) );
6930 putIReg(4, R_ESP, mkexpr(ta));
6931 storeLE( mkexpr(ta), mkexpr(t1) );
6944 assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
6946 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(ta), mkU32(sz)) );
6947 putSReg( sreg, mkexpr(t1) );
6957 assign(t2, loadLE(Ity_I32,mkexpr(t1)));
6958 putIReg(4, R_ESP,binop(Iop_Add32, mkexpr(t1), mkU32(4+d32)));
7026 loadLE(Ity_V128, mkexpr(addr)))
7028 loadLE(Ity_V128, mkexpr(addr)))
7080 loadLE(Ity_I32, mkexpr(addr))) );
7082 binop(op, gpart, mkexpr(epart)) );
7115 loadLE(Ity_I64, mkexpr(addr))) );
7117 binop(op, gpart, mkexpr(epart)) );
7152 IRExpr* src = loadLE(Ity_V128, mkexpr(addr));
7186 mkexpr(oldG0),
7188 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7197 mkexpr(oldG0),
7198 loadLE(Ity_I32, mkexpr(addr)) ));
7199 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7229 mkexpr(oldG0),
7231 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7240 mkexpr(oldG0),
7241 loadLE(Ity_I64, mkexpr(addr)) ));
7242 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7275 epart = loadLE(Ity_V128, mkexpr(addr));
7372 all_lanes ? loadLE(Ity_V128, mkexpr(addr))
7373 : sz == 8 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
7374 : /*sz==4*/ unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr)))
7386 unop(Iop_NotV128, mkexpr(plain)) );
7392 binop(Iop_XorV128, mkexpr(plain), mkV128(mask)) );
7395 putXMMReg( gregOfRM(rm), mkexpr(plain) );
7425 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
7432 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
7452 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
7453 binop(op, mkexpr(g0), mkexpr(amt8)),
7462 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
7463 binop(op, mkexpr(g0), mkexpr(amt8)),
7464 binop(op, mkexpr(g0), mkU8(size-1))
7472 putXMMReg( gregOfRM(rm), mkexpr(g1) );
7514 : binop(op, mkexpr(e0), mkU8(amt))
7519 ? binop(op, mkexpr(e0), mkU8(size-1))
7520 : binop(op, mkexpr(e0), mkU8(amt))
7527 putXMMReg( eregOfRM(rm), mkexpr(e1) );
7556 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
7557 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
7568 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
7569 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
7570 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
7571 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
7581 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
7582 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
7595 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
7596 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
7607 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
7608 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
7609 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
7610 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
7620 binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)),
7621 binop(Iop_16HLto32, mkexpr(t1), mkexpr(t0))
7651 mkexpr(t1),
7669 binop(Iop_Shr32, mkexpr(t1), mkU8(10)),
7681 binop(Iop_Shr32, mkexpr(t1), mkU8(21)),
7694 binop(Iop_Shr32, mkexpr(t1), mkU8(18)),
7705 binop(Iop_And32, mkexpr(t1), mkU32(1<<18)),
7736 binop(Iop_InterleaveHI16x4, mkexpr(aa), mkexpr(aa)),
7740 binop(Iop_InterleaveLO16x4, mkexpr(aa), mkexpr(aa)),
7744 binop(Iop_InterleaveHI16x4, mkexpr(bb), mkexpr(bb)),
7748 binop(Iop_InterleaveLO16x4, mkexpr(bb), mkexpr(bb)),
7759 binop(Iop_Mul32x2, mkexpr(aahi32s), mkexpr(bbhi32s)),
7762 mkexpr(one32x2)
7775 binop(Iop_Mul32x2, mkexpr(aalo32s), mkexpr(bblo32s)),
7778 mkexpr(one32x2)
7784 binop(Iop_CatEvenLanes16x4, mkexpr(rHi), mkexpr(rLo));
7815 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
7816 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
7817 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
7821 binop(Iop_And64, mkexpr(bb), mkexpr(posMask)),
7822 binop(Iop_And64, mkexpr(bbNeg), mkexpr(negMask)) );
7853 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
7854 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
7856 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
7859 binop(Iop_And64, mkexpr(aa), mkexpr(posMask)),
7860 binop(Iop_And64, mkexpr(aaNeg), mkexpr(negMask)) );
7869 mkexpr(hi64), mkU8(8*(8-byteShift))),
7870 binop(Iop_Shr64, mkexpr(lo64), mkU8(8*byteShift))
7883 binop(Iop_And32,mkexpr(effective_addr),mkU32(0xF)),
8029 binop(Iop_Shl32, mkexpr(t1), mkU8(24)),
8032 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t1), mkU8(8)),
8035 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(8)),
8037 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(24)),
8046 binop(Iop_Shl16, mkexpr(t1), mkU8(8)),
8047 binop(Iop_Shr16, mkexpr(t1), mkU8(8)) ));
8163 putIReg(4, R_ESP, mkexpr(t2));
8164 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta));
8340 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
8345 d->mAddr = mkexpr(addr);
8414 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
8419 d->mAddr = mkexpr(addr);
8537 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
8550 unop(Iop_F32toF64,mkexpr(argL)),
8551 unop(Iop_F32toF64,mkexpr(argR))),
8576 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
8587 mkexpr(rmode),
8589 unop(Iop_64to32, mkexpr(arg64)) )) );
8594 mkexpr(rmode),
8596 unop(Iop_64HIto32, mkexpr(arg64)) )) );
8616 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
8627 mkexpr(rmode),
8628 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
8656 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8658 mkexpr(addr),
8676 mkexpr(rmode),
8677 unop( Iop_F32toF64, mkexpr(f32hi) ) ),
8679 mkexpr(rmode),
8680 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8684 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
8708 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8723 mkexpr(rmode),
8724 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8770 mkIRExprVec_1( loadLE(Ity_I32, mkexpr(addr)) )
8774 put_sse_roundingmode( unop(Iop_64to32, mkexpr(t64)) );
8775 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
8776 put_emwarn( mkexpr(ew) );
8782 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
8817 storeLE( mkexpr(addr), getMMXReg(gregOfRM(modrm)) );
8856 case 0: assign(t5, mkexpr(t0)); break;
8857 case 1: assign(t5, mkexpr(t1)); break;
8858 case 2: assign(t5, mkexpr(t2)); break;
8859 case 3: assign(t5, mkexpr(t3)); break;
8862 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t5)));
8900 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
8913 putMMXReg(gregOfRM(modrm), mkexpr(t6));
8964 assign(t1, unop(Iop_8Uto32, unop(Iop_GetMSBs8x8, mkexpr(t0))));
8965 putIReg(4, gregOfRM(modrm), mkexpr(t1));
9061 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
9076 putMMXReg(gregOfRM(modrm), mkexpr(dV));
9139 loadLE(Ity_V128, mkexpr(addr)) );
9158 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
9180 loadLE(Ity_I64, mkexpr(addr)) );
9193 storeLE( mkexpr(addr),
9218 loadLE(Ity_I64, mkexpr(addr)) );
9231 storeLE( mkexpr(addr),
9267 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
9268 binop(Iop_Or32, mkexpr(t2), mkexpr(t3))
9285 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
9314 loadLE(Ity_I32, mkexpr(addr)) );
9331 storeLE( mkexpr(addr),
9411 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9467 storeLE( mkexpr(addr),
9511 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9602 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
9614 binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)),
9637 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9645 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)))
9650 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)))
9670 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9680 mkexpr(rmode), \
9681 unop(Iop_I32StoF64,mkexpr(_t)))
9708 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9718 unop(Iop_V128to64, mkexpr
9720 unop(Iop_V128HIto64, mkexpr(argV))) );
9723 mkexpr(rmode), \
9724 mkexpr(_t) )
9759 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9761 mkexpr(addr),
9778 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64hi) ),
9779 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo) )
9783 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
9804 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9814 unop(Iop_V128to64, mkexpr(argV))) );
9816 unop(Iop_V128HIto64, mkexpr(argV))) );
9819 mkexpr(rmode), \
9820 mkexpr(_t) )
9852 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9860 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)) )
9865 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)) )
9885 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9898 mkexpr(rmode), \
9900 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
9927 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
9929 binop(Iop_Add32,mkexpr(addr),mkU32(4))) );
9936 unop(Iop_F32toF64, mkexpr(f32hi)) );
9938 unop(Iop_F32toF64, mkexpr(f32lo)) );
9963 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9977 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo)) );
9997 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
10006 binop( Iop_F64toF32, mkexpr(rmode), mkexpr(f64lo) )
10026 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
10034 unop(Iop_I32StoF64, mkexpr(arg32)) );
10053 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
10060 unop( Iop_F32toF64, mkexpr(f32lo) ) );
10079 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10090 unop(Iop_V128to64, mkexpr(argV))) );
10092 unop(Iop_V128HIto64, mkexpr(argV))) );
10095 mkexpr(rmode), \
10096 mkexpr(_t) )
10123 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10136 mkexpr(rmode), \
10138 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10222 loadLE(Ity_V128, mkexpr(addr)) );
10242 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10266 unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)) )
10285 storeLE( mkexpr(addr),
10305 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10326 loadLE(Ity_V128, mkexpr(addr)) );
10349 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10383 loadLE(Ity_I64, mkexpr(addr)) );
10397 storeLE( mkexpr(addr),
10417 loadLE(Ity_I64, mkexpr(addr)) );
10431 storeLE( mkexpr(addr),
10458 binop(Iop_Or32, mkexpr(t0), mkexpr(t1))
10492 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
10496 mkexpr(regD),
10497 mkexpr(mask) ),
10499 mkexpr(olddata),
10500 unop(Iop_NotV128, mkexpr(mask)))) );
10501 storeLE( mkexpr(addr), mkexpr(newdata) );
10517 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10532 storeLE( mkexpr(addr), getIReg(4, gregOfRM(modrm)) );
10550 storeLE( mkexpr(addr),
10601 loadLE(Ity_I64, mkexpr(addr)) );
10622 storeLE( mkexpr(addr),
10672 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10680 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10681 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10682 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10683 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10685 # define SELD(n) mkexpr((n)==0 ? d0 : d1)
10686 # define SELS(n) mkexpr((n)==0 ? s0 : s1)
10750 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10757 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10758 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10759 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10760 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10764 binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
10767 binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
10946 case 0: assign(t4, unop(Iop_32to16, mkexpr(t0))); break;
10947 case 1: assign(t4, unop(Iop_32HIto16, mkexpr(t0))); break;
10948 case 2: assign(t4, unop(Iop_32to16, mkexpr(t1))); break;
10949 case 3: assign(t4, unop(Iop_32HIto16, mkexpr(t1))); break;
10950 case 4: assign(t4, unop(Iop_32to16, mkexpr(t2))); break;
10951 case 5: assign(t4, unop(Iop_32HIto16, mkexpr(t2))); break;
10952 case 6: assign(t4, unop(Iop_32to16, mkexpr(t3))); break;
10953 case 7: assign(t4, unop(Iop_32HIto16, mkexpr(t3))); break;
10956 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t4)));
10984 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
10990 putXMMRegLane16( gregOfRM(modrm), lane & 7, mkexpr(t4) );
11014 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
11020 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
11021 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
11022 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
11023 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
11028 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
11034 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
11036 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
11037 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11083 unop(Iop_GetMSBs8x8, mkexpr(t1)),
11084 unop(Iop_GetMSBs8x8, mkexpr(t0)))));
11085 putIReg(4, gregOfRM(modrm), mkexpr(t5));
11135 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
11141 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
11142 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
11144 binop( Iop_MullU32, mkexpr(t0), mkexpr(t1) ) );
11171 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11180 assign( t0, binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) );
11181 putXMMRegLane64( gregOfRM(modrm), 0, mkexpr(t0) );
11182 assign( t1, binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)) );
11183 putXMMRegLane64( gregOfRM(modrm), 1, mkexpr(t1) );
11213 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
11219 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
11220 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
11221 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
11222 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
11227 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
11233 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
11235 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
11236 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11257 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11272 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11297 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11304 assign( sVhi, unop(Iop_V128HIto64, mkexpr(sV)) );
11314 mkexpr(dVhi),
11315 unop(Iop_V128to64, mkexpr(sV))) );
11316 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11341 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11348 assign( sVlo, unop(Iop_V128to64, mkexpr(sV)) );
11358 unop(Iop_V128HIto64, mkexpr(sV)),
11359 mkexpr(dVlo) ) );
11360 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11403 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11404 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11407 assign( lo64r, mkexpr(lo64) );
11408 assign( hi64r, mkexpr(hi64) );
11413 assign( hi64r, mkexpr(lo64) );
11419 mkexpr(lo64),
11423 mkexpr(lo64),
11427 binop(Iop_Shl64, mkexpr(hi64),
11429 binop(Iop_Shr64, mkexpr(lo64),
11434 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11435 putXMMReg(reg, mkexpr(dV));
11533 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11534 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11537 assign( lo64r, mkexpr(lo64) );
11538 assign( hi64r, mkexpr(hi64) );
11543 assign( lo64r, mkexpr(hi64) );
11549 mkexpr(hi64),
11553 mkexpr(hi64),
11557 binop(Iop_Shr64, mkexpr(lo64),
11559 binop(Iop_Shl64, mkexpr(hi64),
11565 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11566 putXMMReg(reg, mkexpr(dV));
11768 mkexpr(addr),
11815 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11841 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
11844 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
11850 putXMMReg( gregOfRM(modrm), binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
11872 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11881 assign( addV, triop(Iop_Add32Fx4, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11882 assign( subV, triop(Iop_Sub32Fx4, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11909 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11918 assign( addV, triop(Iop_Add64Fx2, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11919 assign( subV, triop(Iop_Sub64Fx2, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11921 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
11922 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
11925 binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
11951 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11968 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
11995 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
12003 assign( e1, unop(Iop_V128HIto64, mkexpr(eV) ));
12004 assign( e0, unop(Iop_V128to64, mkexpr(eV) ));
12005 assign( g1, unop(Iop_V128HIto64, mkexpr(gV) ));
12006 assign( g0, unop(Iop_V128to64, mkexpr(gV) ));
12008 assign( leftV, binop(Iop_64HLtoV128, mkexpr(e0),mkexpr(g0)) );
12009 assign( rightV, binop(Iop_64HLtoV128, mkexpr(e1),mkexpr(g1)) );
12014 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
12026 loadLE(Ity_V128, mkexpr(addr)) );
12064 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12072 binop(Iop_SarN16x4, mkexpr(sV), mkU8(8)) );
12075 binop(Iop_ShlN16x4, mkexpr(sV), mkU8(8)),
12078 binop(Iop_ShrN16x4, mkexpr(dV), mkU8(8)) );
12081 binop(Iop_ShlN16x4, mkexpr(dV), mkU8(8)),
12087 binop(Iop_Mul16x4, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
12088 binop(Iop_Mul16x4, mkexpr(sVevensSX), mkexpr(dVevensZX))
12116 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12124 binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
12127 binop(Iop_ShlN16x8, mkexpr(sV), mkU8(8)),
12130 binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
12133 binop(Iop_ShlN16x8, mkexpr(dV), mkU8(8)),
12139 binop(Iop_Mul16x8, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
12140 binop(Iop_Mul16x8, mkexpr(sVevensSX), mkexpr(dVevensZX))
12197 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12206 binop(opCatE,mkexpr(sV),mkexpr(dV)),
12207 binop(opCatO,mkexpr(sV),mkexpr(dV))
12267 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12273 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12274 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12275 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12276 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12285 binop(opCatE,mkexpr(sHi),mkexpr(sLo)),
12286 binop(opCatO,mkexpr(sHi),mkexpr(sLo))
12289 binop(opCatE,mkexpr(dHi),mkexpr(dLo)),
12290 binop(opCatO,mkexpr(dHi),mkexpr(dLo))
12315 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12323 dis_PMULHRSW_helper( mkexpr(sV), mkexpr(dV) )
12350 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12356 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12357 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12358 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12359 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12364 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
12365 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
12400 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12408 dis_PSIGN_helper( mkexpr(sV), mkexpr(dV), laneszB )
12446 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12452 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12453 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12454 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12455 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12460 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
12461 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
12494 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12502 dis_PABS_helper( mkexpr(sV), laneszB )
12536 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12542 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12543 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12548 dis_PABS_helper( mkexpr(sHi), laneszB ),
12549 dis_PABS_helper( mkexpr(sLo), laneszB )
12575 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12584 assign( res, mkexpr(sV) );
12589 binop(Iop_Shr64, mkexpr(sV), mkU8(8*d32)),
12590 binop(Iop_Shl64, mkexpr(dV), mkU8(8*(8-d32))
12594 assign( res, mkexpr(dV) );
12597 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d32-8))) );
12605 putMMXReg( gregOfRM(modrm), mkexpr(res) );
12634 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12642 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12643 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12644 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12645 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12648 assign( rHi, mkexpr(sHi) );
12649 assign( rLo, mkexpr(sLo) );
12656 assign( rHi, mkexpr(dLo) );
12657 assign( rLo, mkexpr(sHi) );
12664 assign( rHi, mkexpr(dHi) );
12665 assign( rLo, mkexpr(dLo) );
12668 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-16))) );
12673 assign( rLo, mkexpr(dHi) );
12677 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-24))) );
12688 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12710 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12723 mkexpr(dV),
12724 binop(Iop_And64, mkexpr(sV), mkU64(0x0707070707070707ULL))
12727 unop(Iop_Not64, binop(Iop_SarN8x8, mkexpr(sV), mkU8(7)))
12765 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12771 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12772 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12773 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12774 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12788 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sHi),mkU8(7))));
12793 binop(Iop_ShlN8x8,mkexpr(sHi),mkU8(4)),
12796 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
12803 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7hi)),
12804 mkexpr(maskBit3hi)),
12806 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7hi)),
12807 unop(Iop_Not64,mkexpr(maskBit3hi))) ));
12809 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
12815 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sLo),mkU8(7))));
12820 binop(Iop_ShlN8x8,mkexpr(sLo),mkU8(4)),
12823 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
12830 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7lo)),
12831 mkexpr(maskBit3lo)),
12833 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7lo)),
12834 unop(Iop_Not64,mkexpr(maskBit3lo))) ));
12836 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
12840 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12859 assign(src, loadLE(ty, mkexpr(addr)));
12861 putIReg(sz, gregOfRM(modrm), mkexpr(dst));
12866 storeLE(mkexpr(addr), mkexpr(dst));
12910 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
12923 mkU32(imm & 3), mkexpr(src)) );
12926 putXMMRegLane64F( gregOfRM(modrm), 0, mkexpr(res) );
12928 putXMMRegLane32F( gregOfRM(modrm), 0, mkexpr(res) );
12951 assign(src, loadLE(ty, mkexpr(addr)));
12958 putIReg(sz, gregOfRM(modrm), mkexpr(res));
12966 assign(src32, widenUto32(mkexpr(src)));
12967 assign(res32, widenUto32(mkexpr(res)));
12975 binop(Iop_CmpEQ32, mkexpr(res32), mkU32(0))),
12979 binop(Iop_CmpEQ32, mkexpr(src32), mkU32(0))),
12987 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
13052 assign(t2, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(0) )));
13053 assign(t3, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(4) )));
13054 assign(t4, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(8) )));
13056 putIReg(4, R_ESP,binop(Iop_Add32, mkexpr(t1), mkU32(12)));
13058 putSReg( R_CS, unop(Iop_32to16, mkexpr(t3)) );
13088 putIReg(4, R_ESP, mkexpr(t1));
13089 storeLE( mkexpr(t1), mkU32(guest_EIP_bbstart+delta));
13131 putIReg(4, R_ESP, mkexpr(t1));
13132 assign(t2, loadLE(Ity_I32,mkexpr(t1)));
13133 putIReg(4, R_EBP, mkexpr(t2));
13134 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(4)) );
13167 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
13169 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
13175 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
13217 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
13219 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
13225 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
13314 putIReg(sz, (UInt)(opc - 0x40), mkexpr(t1));
13333 putIReg(sz, (UInt)(opc - 0x48), mkexpr(t1));
13597 putIReg(sz, gregOfRM(modrm), mkexpr(addr));
13618 putIReg(sz, R_EAX, loadLE(ty, mkexpr(addr)));
13631 storeLE( mkexpr(addr), getIReg(sz,R_EAX) );
13681 storeLE(mkexpr(addr), mkU(szToITy(sz), d32));
13905 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
13906 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13907 putIReg(sz, opc-0x58, mkexpr(t1));
13915 assign(t1, widenUto32(loadLE(szToITy(sz),mkexpr(t2))));
13916 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13935 putIReg(4,R_EAX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(28)) ));
13936 putIReg(4,R_ECX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(24)) ));
13937 putIReg(4,R_EDX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(20)) ));
13938 putIReg(4,R_EBX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(16)) ));
13940 putIReg(4,R_EBP, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 8)) ));
13941 putIReg(4,R_ESI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 4)) ));
13942 putIReg(4,R_EDI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 0)) ));
13945 putIReg( 4, R_ESP, binop(Iop_Add32, mkexpr(t5), mkU32(8*4)) );
13967 assign( t3, loadLE(ty, mkexpr(t1)) );
13975 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(sz)) );
13979 storeLE( mkexpr(addr), mkexpr(t3) );
14012 putIReg(4, R_ESP, mkexpr(t2) );
14013 storeLE(mkexpr(t2),mkexpr(t1));
14028 putIReg(4, R_ESP, mkexpr(t1) );
14033 storeLE( mkexpr(t1), mkU(ty,d32) );
14042 putIReg(4, R_ESP, mkexpr(t1) );
14058 mkexpr(t2),
14067 mkexpr(t3),
14077 mkexpr(t4),
14086 storeLE( mkexpr(t1), unop(Iop_32to16,mkexpr(t5)) );
14088 storeLE( mkexpr(t1), mkexpr(t5) );
14108 assign( t5, binop(Iop_Sub32, mkexpr(t0), mkU32(8*4)) );
14111 putIReg(4, R_ESP, mkexpr(t5));
14114 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(28)), getIReg(4,R_EAX) );
14115 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(24)), getIReg(4,R_ECX) );
14116 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(20)), getIReg(4,R_EDX) );
14117 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(16)), getIReg(4,R_EBX) );
14118 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(12)), mkexpr(t0) /*esp*/);
14119 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 8)), getIReg(4,R_EBP) );
14120 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 4)), getIReg(4,R_ESI) );
14121 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 0)), getIReg(4,R_EDI) );
14191 assign( t1, binop(Iop_And32, mkexpr(t0),
14196 assign( t1, binop(Iop_Or32, mkexpr(t0),
14201 assign( t1, binop(Iop_Xor32, mkexpr(t0),
14210 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t1) ));
14223 binop(Iop_Shl32, mkexpr(t0), mkU8(31)),
14225 putIReg(1, R_EAX, unop(Iop_32to8, mkexpr(t1)) );
14361 putIReg(sz, gregOfRM(modrm), mkexpr(t1));
14362 putIReg(sz, eregOfRM(modrm), mkexpr(t2));
14370 assign( t1, loadLE(ty,mkexpr(addr)) );
14372 casLE( mkexpr(addr),
14373 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
14374 putIReg( sz, gregOfRM(modrm), mkexpr(t1) );
14453 mkIRExprVec_2( mkexpr(t1), mkU32(sz) )
14457 putIReg(sz, R_EAX, narrowTo( ty, mkexpr(t2) ) );
14499 mkIRExprVec_3( mkexpr(t1),
14696 putIReg(4, opc-0xC8, mkexpr(t2));
14779 Iend_LE, mkexpr(addr),
14780 mkexpr(expdHi), mkexpr(expdLo),
14781 mkexpr(dataHi), mkexpr(dataLo)
14788 binop(Iop_Xor32, mkexpr(oldHi), mkexpr(expdHi)),
14789 binop(Iop_Xor32, mkexpr(oldLo), mkexpr(expdLo))
14801 IRExpr_ITE( mkexpr(success),
14802 mkexpr(expdHi), mkexpr(oldHi)
14805 IRExpr_ITE( mkexpr(success),
14806 mkexpr(expdLo), mkexpr(oldLo)
14815 binop(Iop_And32, mkexpr(flags_old),
14819 unop(Iop_1Uto32, mkexpr(success)), mkU32(1)),
14823 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(flags_new) ));
15087 putIReg(4, R_EDX, unop(Iop_64HIto32, mkexpr(val)));
15088 putIReg(4, R_EAX, unop(Iop_64to32, mkexpr(val)));
15127 putIReg(1, eregOfRM(modrm), mkexpr(t1));
15133 storeLE( mkexpr(addr), mkexpr(t1) );
15334 mkIRExprVec_2( mkexpr(addr),
15339 d->mAddr = mkexpr(addr);
