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)) );
7147 unop(op, loadLE(Ity_V128, mkexpr(addr))) );
7177 mkexpr(oldG0),
7179 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7188 mkexpr(oldG0),
7189 loadLE(Ity_I32, mkexpr(addr)) ));
7190 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7220 mkexpr(oldG0),
7222 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7231 mkexpr(oldG0),
7232 loadLE(Ity_I64, mkexpr(addr)) ));
7233 putXMMReg( gregOfRM(rm), unop(op, mkexpr(oldG1)) );
7266 epart = loadLE(Ity_V128, mkexpr(addr));
7363 all_lanes ? loadLE(Ity_V128, mkexpr(addr))
7364 : sz == 8 ? unop( Iop_64UtoV128, loadLE(Ity_I64, mkexpr(addr)))
7365 : /*sz==4*/ unop( Iop_32UtoV128, loadLE(Ity_I32, mkexpr(addr)))
7377 unop(Iop_NotV128, mkexpr(plain)) );
7383 binop(Iop_XorV128, mkexpr(plain), mkV128(mask)) );
7386 putXMMReg( gregOfRM(rm), mkexpr(plain) );
7416 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
7423 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
7443 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
7444 binop(op, mkexpr(g0), mkexpr(amt8)),
7453 binop(Iop_CmpLT32U,mkexpr(amt),mkU32(size)),
7454 binop(op, mkexpr(g0), mkexpr(amt8)),
7455 binop(op, mkexpr(g0), mkU8(size-1))
7463 putXMMReg( gregOfRM(rm), mkexpr(g1) );
7505 : binop(op, mkexpr(e0), mkU8(amt))
7510 ? binop(op, mkexpr(e0), mkU8(size-1))
7511 : binop(op, mkexpr(e0), mkU8(amt))
7518 putXMMReg( eregOfRM(rm), mkexpr(e1) );
7547 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
7548 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
7559 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
7560 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
7561 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
7562 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
7572 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
7573 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
7586 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
7587 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
7598 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
7599 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
7600 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
7601 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
7611 binop(Iop_16HLto32, mkexpr(t3), mkexpr(t2)),
7612 binop(Iop_16HLto32, mkexpr(t1), mkexpr(t0))
7642 mkexpr(t1),
7660 binop(Iop_Shr32, mkexpr(t1), mkU8(10)),
7672 binop(Iop_Shr32, mkexpr(t1), mkU8(21)),
7685 binop(Iop_Shr32, mkexpr(t1), mkU8(18)),
7696 binop(Iop_And32, mkexpr(t1), mkU32(1<<18)),
7727 binop(Iop_InterleaveHI16x4, mkexpr(aa), mkexpr(aa)),
7731 binop(Iop_InterleaveLO16x4, mkexpr(aa), mkexpr(aa)),
7735 binop(Iop_InterleaveHI16x4, mkexpr(bb), mkexpr(bb)),
7739 binop(Iop_InterleaveLO16x4, mkexpr(bb), mkexpr(bb)),
7750 binop(Iop_Mul32x2, mkexpr(aahi32s), mkexpr(bbhi32s)),
7753 mkexpr(one32x2)
7766 binop(Iop_Mul32x2, mkexpr(aalo32s), mkexpr(bblo32s)),
7769 mkexpr(one32x2)
7775 binop(Iop_CatEvenLanes16x4, mkexpr(rHi), mkexpr(rLo));
7806 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
7807 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
7808 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
7812 binop(Iop_And64, mkexpr(bb), mkexpr(posMask)),
7813 binop(Iop_And64, mkexpr(bbNeg), mkexpr(negMask)) );
7844 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
7845 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
7847 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
7850 binop(Iop_And64, mkexpr(aa), mkexpr(posMask)),
7851 binop(Iop_And64, mkexpr(aaNeg), mkexpr(negMask)) );
7860 binop(Iop_Shl64, mkexpr(hi64), mkU8(8*(8-byteShift))),
7861 binop(Iop_Shr64, mkexpr(lo64), mkU8(8*byteShift))
7874 binop(Iop_And32,mkexpr(effective_addr),mkU32(0xF)),
8020 binop(Iop_Shl32, mkexpr(t1), mkU8(24)),
8023 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t1), mkU8(8)),
8026 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(8)),
8028 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t1), mkU8(24)),
8037 binop(Iop_Shl16, mkexpr(t1), mkU8(8)),
8038 binop(Iop_Shr16, mkexpr(t1), mkU8(8)) ));
8154 putIReg(4, R_ESP, mkexpr(t2));
8155 storeLE( mkexpr(t2), mkU32(guest_EIP_bbstart+delta));
8331 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
8336 d->mAddr = mkexpr(addr);
8405 mkIRExprVec_2( IRExpr_BBPTR(), mkexpr(addr) )
8410 d->mAddr = mkexpr(addr);
8528 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
8541 unop(Iop_F32toF64,mkexpr(argL)),
8542 unop(Iop_F32toF64,mkexpr(argR))),
8567 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
8578 mkexpr(rmode),
8580 unop(Iop_64to32, mkexpr(arg64)) )) );
8585 mkexpr(rmode),
8587 unop(Iop_64HIto32, mkexpr(arg64)) )) );
8607 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
8618 mkexpr(rmode),
8619 unop(Iop_I32StoF64, mkexpr(arg32)) ) );
8647 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8649 mkexpr(addr),
8667 mkexpr(rmode),
8668 unop( Iop_F32toF64, mkexpr(f32hi) ) ),
8670 mkexpr(rmode),
8671 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8675 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
8699 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
8714 mkexpr(rmode),
8715 unop( Iop_F32toF64, mkexpr(f32lo) ) )
8761 mkIRExprVec_1( loadLE(Ity_I32, mkexpr(addr)) )
8765 put_sse_roundingmode( unop(Iop_64to32, mkexpr(t64)) );
8766 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
8767 put_emwarn( mkexpr(ew) );
8773 binop(Iop_CmpNE32, mkexpr(ew), mkU32(0)),
8808 storeLE( mkexpr(addr), getMMXReg(gregOfRM(modrm)) );
8847 case 0: assign(t5, mkexpr(t0)); break;
8848 case 1: assign(t5, mkexpr(t1)); break;
8849 case 2: assign(t5, mkexpr(t2)); break;
8850 case 3: assign(t5, mkexpr(t3)); break;
8853 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t5)));
8891 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
8904 putMMXReg(gregOfRM(modrm), mkexpr(t6));
8955 assign(t1, unop(Iop_8Uto32, unop(Iop_GetMSBs8x8, mkexpr(t0))));
8956 putIReg(4, gregOfRM(modrm), mkexpr(t1));
9052 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
9067 putMMXReg(gregOfRM(modrm), mkexpr(dV));
9130 loadLE(Ity_V128, mkexpr(addr)) );
9149 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
9171 loadLE(Ity_I64, mkexpr(addr)) );
9184 storeLE( mkexpr(addr),
9209 loadLE(Ity_I64, mkexpr(addr)) );
9222 storeLE( mkexpr(addr),
9258 binop(Iop_Or32, mkexpr(t0), mkexpr(t1)),
9259 binop(Iop_Or32, mkexpr(t2), mkexpr(t3))
9276 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
9305 loadLE(Ity_I32, mkexpr(addr)) );
9322 storeLE( mkexpr(addr),
9402 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9458 storeLE( mkexpr(addr),
9502 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
9593 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
9605 binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)),
9628 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9636 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)))
9641 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)))
9661 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9671 mkexpr(rmode), \
9672 unop(Iop_I32StoF64,mkexpr(_t)))
9699 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9709 unop(Iop_V128to64, mkexpr(argV))) );
9711 unop(Iop_V128HIto64, mkexpr(argV))) );
9714 mkexpr(rmode), \
9715 mkexpr(_t) )
9750 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9752 mkexpr(addr),
9769 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64hi) ),
9770 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo) )
9774 putMMXReg(gregOfRM(modrm), mkexpr(dst64));
9795 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9805 unop(Iop_V128to64, mkexpr(argV))) );
9807 unop(Iop_V128HIto64, mkexpr(argV))) );
9810 mkexpr(rmode), \
9811 mkexpr(_t) )
9843 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9851 unop(Iop_I32StoF64, unop(Iop_64to32, mkexpr(arg64)) )
9856 unop(Iop_I32StoF64, unop(Iop_64HIto32, mkexpr(arg64)) )
9876 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
9889 mkexpr(rmode), \
9891 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
9918 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
9920 binop(Iop_Add32,mkexpr(addr),mkU32(4))) );
9927 unop(Iop_F32toF64, mkexpr(f32hi)) );
9929 unop(Iop_F32toF64, mkexpr(f32lo)) );
9954 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9968 binop( Iop_F64toI32S, mkexpr(rmode), mkexpr(f64lo)) );
9988 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
9997 binop( Iop_F64toF32, mkexpr(rmode), mkexpr(f64lo) )
10017 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
10025 unop(Iop_I32StoF64, mkexpr(arg32)) );
10044 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
10051 unop( Iop_F32toF64, mkexpr(f32lo) ) );
10070 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10081 unop(Iop_V128to64, mkexpr(argV))) );
10083 unop(Iop_V128HIto64, mkexpr(argV))) );
10086 mkexpr(rmode), \
10087 mkexpr(_t) )
10114 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10127 mkexpr(rmode), \
10129 unop( Iop_ReinterpI32asF32, mkexpr(_t))) )
10213 loadLE(Ity_V128, mkexpr(addr)) );
10233 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10257 unop( Iop_32UtoV128,loadLE(Ity_I32, mkexpr(addr)) )
10276 storeLE( mkexpr(addr),
10296 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10317 loadLE(Ity_V128, mkexpr(addr)) );
10340 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10374 loadLE(Ity_I64, mkexpr(addr)) );
10388 storeLE( mkexpr(addr),
10408 loadLE(Ity_I64, mkexpr(addr)) );
10422 storeLE( mkexpr(addr),
10449 binop(Iop_Or32, mkexpr(t0), mkexpr(t1))
10483 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
10487 mkexpr(regD),
10488 mkexpr(mask) ),
10490 mkexpr(olddata),
10491 unop(Iop_NotV128, mkexpr(mask)))) );
10492 storeLE( mkexpr(addr), mkexpr(newdata) );
10508 storeLE( mkexpr(addr), getXMMReg(gregOfRM(modrm)) );
10523 storeLE( mkexpr(addr), getIReg(4, gregOfRM(modrm)) );
10541 storeLE( mkexpr(addr),
10592 loadLE(Ity_I64, mkexpr(addr)) );
10613 storeLE( mkexpr(addr),
10663 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10671 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10672 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10673 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10674 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10676 # define SELD(n) mkexpr((n)==0 ? d0 : d1)
10677 # define SELS(n) mkexpr((n)==0 ? s0 : s1)
10741 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10748 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10749 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10750 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10751 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10755 binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
10758 binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
10937 case 0: assign(t4, unop(Iop_32to16, mkexpr(t0))); break;
10938 case 1: assign(t4, unop(Iop_32HIto16, mkexpr(t0))); break;
10939 case 2: assign(t4, unop(Iop_32to16, mkexpr(t1))); break;
10940 case 3: assign(t4, unop(Iop_32HIto16, mkexpr(t1))); break;
10941 case 4: assign(t4, unop(Iop_32to16, mkexpr(t2))); break;
10942 case 5: assign(t4, unop(Iop_32HIto16, mkexpr(t2))); break;
10943 case 6: assign(t4, unop(Iop_32to16, mkexpr(t3))); break;
10944 case 7: assign(t4, unop(Iop_32HIto16, mkexpr(t3))); break;
10947 putIReg(4, gregOfRM(modrm), unop(Iop_16Uto32, mkexpr(t4)));
10975 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
10981 putXMMRegLane16( gregOfRM(modrm), lane & 7, mkexpr(t4) );
11005 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
11011 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
11012 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
11013 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
11014 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
11019 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
11025 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
11027 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
11028 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11074 unop(Iop_GetMSBs8x8, mkexpr(t1)),
11075 unop(Iop_GetMSBs8x8, mkexpr(t0)))));
11076 putIReg(4, gregOfRM(modrm), mkexpr(t5));
11126 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
11132 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
11133 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
11135 binop( Iop_MullU32, mkexpr(t0), mkexpr(t1) ) );
11162 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11171 assign( t0, binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) );
11172 putXMMRegLane64( gregOfRM(modrm), 0, mkexpr(t0) );
11173 assign( t1, binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)) );
11174 putXMMRegLane64( gregOfRM(modrm), 1, mkexpr(t1) );
11204 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
11210 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
11211 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
11212 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
11213 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
11218 mkIRExprVec_2( mkexpr(s1Hi), mkexpr(s2Hi))
11224 mkIRExprVec_2( mkexpr(s1Lo), mkexpr(s2Lo))
11226 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
11227 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11248 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11263 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11288 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11295 assign( sVhi, unop(Iop_V128HIto64, mkexpr(sV)) );
11305 mkexpr(dVhi),
11306 unop(Iop_V128to64, mkexpr(sV))) );
11307 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11332 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11339 assign( sVlo, unop(Iop_V128to64, mkexpr(sV)) );
11349 unop(Iop_V128HIto64, mkexpr(sV)),
11350 mkexpr(dVlo) ) );
11351 putXMMReg(gregOfRM(modrm), mkexpr(dV));
11394 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11395 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11398 assign( lo64r, mkexpr(lo64) );
11399 assign( hi64r, mkexpr(hi64) );
11404 assign( hi64r, mkexpr(lo64) );
11410 mkexpr(lo64),
11414 mkexpr(lo64),
11418 binop(Iop_Shl64, mkexpr(hi64),
11420 binop(Iop_Shr64, mkexpr(lo64),
11425 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11426 putXMMReg(reg, mkexpr(dV));
11524 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
11525 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
11528 assign( lo64r, mkexpr(lo64) );
11529 assign( hi64r, mkexpr(hi64) );
11534 assign( lo64r, mkexpr(hi64) );
11540 mkexpr(hi64),
11544 mkexpr(hi64),
11548 binop(Iop_Shr64, mkexpr(lo64),
11550 binop(Iop_Shl64, mkexpr(hi64),
11556 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
11557 putXMMReg(reg, mkexpr(dV));
11759 mkexpr(addr),
11810 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11836 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
11839 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
11845 putXMMReg( gregOfRM(modrm), binop(Iop_64HLtoV128,mkexpr(d0),mkexpr(d0)) );
11867 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11876 assign( addV, triop(Iop_Add32Fx4, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11877 assign( subV, triop(Iop_Sub32Fx4, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11904 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11913 assign( addV, triop(Iop_Add64Fx2, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11914 assign( subV, triop(Iop_Sub64Fx2, mkexpr(rm), mkexpr(gV), mkexpr(eV)) );
11916 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
11917 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
11920 binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
11946 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11963 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
11990 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
11998 assign( e1, unop(Iop_V128HIto64, mkexpr(eV) ));
11999 assign( e0, unop(Iop_V128to64, mkexpr(eV) ));
12000 assign( g1, unop(Iop_V128HIto64, mkexpr(gV) ));
12001 assign( g0, unop(Iop_V128to64, mkexpr(gV) ));
12003 assign( leftV, binop(Iop_64HLtoV128, mkexpr(e0),mkexpr(g0)) );
12004 assign( rightV, binop(Iop_64HLtoV128, mkexpr(e1),mkexpr(g1)) );
12009 mkexpr(rm), mkexpr(leftV), mkexpr(rightV) ) );
12021 loadLE(Ity_V128, mkexpr(addr)) );
12059 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12067 binop(Iop_SarN16x4, mkexpr(sV), mkU8(8)) );
12070 binop(Iop_ShlN16x4, mkexpr(sV), mkU8(8)),
12073 binop(Iop_ShrN16x4, mkexpr(dV), mkU8(8)) );
12076 binop(Iop_ShlN16x4, mkexpr(dV), mkU8(8)),
12082 binop(Iop_Mul16x4, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
12083 binop(Iop_Mul16x4, mkexpr(sVevensSX), mkexpr(dVevensZX))
12111 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12119 binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
12122 binop(Iop_ShlN16x8, mkexpr(sV), mkU8(8)),
12125 binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
12128 binop(Iop_ShlN16x8, mkexpr(dV), mkU8(8)),
12134 binop(Iop_Mul16x8, mkexpr(sVoddsSX), mkexpr(dVoddsZX)),
12135 binop(Iop_Mul16x8, mkexpr(sVevensSX), mkexpr(dVevensZX))
12192 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12201 binop(opCatE,mkexpr(sV),mkexpr(dV)),
12202 binop(opCatO,mkexpr(sV),mkexpr(dV))
12262 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12268 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12269 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12270 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12271 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12280 binop(opCatE,mkexpr(sHi),mkexpr(sLo)),
12281 binop(opCatO,mkexpr(sHi),mkexpr(sLo))
12284 binop(opCatE,mkexpr(dHi),mkexpr(dLo)),
12285 binop(opCatO,mkexpr(dHi),mkexpr(dLo))
12310 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12318 dis_PMULHRSW_helper( mkexpr(sV), mkexpr(dV) )
12345 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12351 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12352 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12353 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12354 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12359 dis_PMULHRSW_helper( mkexpr(sHi), mkexpr(dHi) ),
12360 dis_PMULHRSW_helper( mkexpr(sLo), mkexpr(dLo) )
12395 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12403 dis_PSIGN_helper( mkexpr(sV), mkexpr(dV), laneszB )
12441 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12447 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12448 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12449 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12450 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12455 dis_PSIGN_helper( mkexpr(sHi), mkexpr(dHi), laneszB ),
12456 dis_PSIGN_helper( mkexpr(sLo), mkexpr(dLo), laneszB )
12489 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12497 dis_PABS_helper( mkexpr(sV), laneszB )
12531 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12537 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12538 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12543 dis_PABS_helper( mkexpr(sHi), laneszB ),
12544 dis_PABS_helper( mkexpr(sLo), laneszB )
12570 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12579 assign( res, mkexpr(sV) );
12584 binop(Iop_Shr64, mkexpr(sV), mkU8(8*d32)),
12585 binop(Iop_Shl64, mkexpr(dV), mkU8(8*(8-d32))
12589 assign( res, mkexpr(dV) );
12592 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d32-8))) );
12600 putMMXReg( gregOfRM(modrm), mkexpr(res) );
12629 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12637 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12638 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12639 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12640 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12643 assign( rHi, mkexpr(sHi) );
12644 assign( rLo, mkexpr(sLo) );
12651 assign( rHi, mkexpr(dLo) );
12652 assign( rLo, mkexpr(sHi) );
12659 assign( rHi, mkexpr(dHi) );
12660 assign( rLo, mkexpr(dLo) );
12663 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-16))) );
12668 assign( rLo, mkexpr(dHi) );
12672 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d32-24))) );
12683 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12705 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12718 mkexpr(dV),
12719 binop(Iop_And64, mkexpr(sV), mkU64(0x0707070707070707ULL))
12722 unop(Iop_Not64, binop(Iop_SarN8x8, mkexpr(sV), mkU8(7)))
12760 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12766 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
12767 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
12768 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
12769 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
12783 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sHi),mkU8(7))));
12788 binop(Iop_ShlN8x8,mkexpr(sHi),mkU8(4)),
12791 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
12798 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7hi)),
12799 mkexpr(maskBit3hi)),
12801 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7hi)),
12802 unop(Iop_Not64,mkexpr(maskBit3hi))) ));
12804 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
12810 unop(Iop_Not64, binop(Iop_SarN8x8,mkexpr(sLo),mkU8(7))));
12815 binop(Iop_ShlN8x8,mkexpr(sLo),mkU8(4)),
12818 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
12825 binop(Iop_Perm8x8,mkexpr(dHi),mkexpr(sAnd7lo)),
12826 mkexpr(maskBit3lo)),
12828 binop(Iop_Perm8x8,mkexpr(dLo),mkexpr(sAnd7lo)),
12829 unop(Iop_Not64,mkexpr(maskBit3lo))) ));
12831 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
12835 binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo))
12854 assign(src, loadLE(ty, mkexpr(addr)));
12856 putIReg(sz, gregOfRM(modrm), mkexpr(dst));
12861 storeLE(mkexpr(addr), mkexpr(dst));
12905 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
12918 mkU32(imm & 3), mkexpr(src)) );
12921 putXMMRegLane64F( gregOfRM(modrm), 0, mkexpr(res) );
12923 putXMMRegLane32F( gregOfRM(modrm), 0, mkexpr(res) );
12946 assign(src, loadLE(ty, mkexpr(addr)));
12953 putIReg(sz, gregOfRM(modrm), mkexpr(res));
12961 assign(src32, widenUto32(mkexpr(src)));
12962 assign(res32, widenUto32(mkexpr(res)));
12970 binop(Iop_CmpEQ32, mkexpr(res32), mkU32(0))),
12974 binop(Iop_CmpEQ32, mkexpr(src32), mkU32(0))),
12982 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(oszacp) ));
13047 assign(t2, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(0) )));
13048 assign(t3, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(4) )));
13049 assign(t4, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t1),mkU32(8) )));
13051 putIReg(4, R_ESP,binop(Iop_Add32, mkexpr(t1), mkU32(12)));
13053 putSReg( R_CS, unop(Iop_32to16, mkexpr(t3)) );
13083 putIReg(4, R_ESP, mkexpr(t1));
13084 storeLE( mkexpr(t1), mkU32(guest_EIP_bbstart+delta));
13126 putIReg(4, R_ESP, mkexpr(t1));
13127 assign(t2, loadLE(Ity_I32,mkexpr(t1)));
13128 putIReg(4, R_EBP, mkexpr(t2));
13129 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(4)) );
13162 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
13164 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
13170 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
13212 mkIRExprVec_2( mkexpr(t1), mkU32( opc & 0xFF) )
13214 putIReg(2, R_EAX, unop(Iop_32to16, mkexpr(t2) ));
13220 binop(Iop_Shr32, mkexpr(t2), mkU8(16)),
13309 putIReg(sz, (UInt)(opc - 0x40), mkexpr(t1));
13328 putIReg(sz, (UInt)(opc - 0x48), mkexpr(t1));
13590 putIReg(sz, gregOfRM(modrm), mkexpr(addr));
13611 putIReg(sz, R_EAX, loadLE(ty, mkexpr(addr)));
13624 storeLE( mkexpr(addr), getIReg(sz,R_EAX) );
13674 storeLE(mkexpr(addr), mkU(szToITy(sz), d32));
13898 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
13899 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13900 putIReg(sz, opc-0x58, mkexpr(t1));
13908 assign(t1, widenUto32(loadLE(szToITy(sz),mkexpr(t2))));
13909 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t2), mkU32(sz)));
13928 putIReg(4,R_EAX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(28)) ));
13929 putIReg(4,R_ECX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(24)) ));
13930 putIReg(4,R_EDX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(20)) ));
13931 putIReg(4,R_EBX, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32(16)) ));
13933 putIReg(4,R_EBP, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 8)) ));
13934 putIReg(4,R_ESI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 4)) ));
13935 putIReg(4,R_EDI, loadLE(Ity_I32, binop(Iop_Add32,mkexpr(t5),mkU32( 0)) ));
13938 putIReg( 4, R_ESP, binop(Iop_Add32, mkexpr(t5), mkU32(8*4)) );
13960 assign( t3, loadLE(ty, mkexpr(t1)) );
13968 putIReg(4, R_ESP, binop(Iop_Add32, mkexpr(t1), mkU32(sz)) );
13972 storeLE( mkexpr(addr), mkexpr(t3) );
14005 putIReg(4, R_ESP, mkexpr(t2) );
14006 storeLE(mkexpr(t2),mkexpr(t1));
14021 putIReg(4, R_ESP, mkexpr(t1) );
14026 storeLE( mkexpr(t1), mkU(ty,d32) );
14035 putIReg(4, R_ESP, mkexpr(t1) );
14051 mkexpr(t2),
14060 mkexpr(t3),
14070 mkexpr(t4),
14079 storeLE( mkexpr(t1), unop(Iop_32to16,mkexpr(t5)) );
14081 storeLE( mkexpr(t1), mkexpr(t5) );
14101 assign( t5, binop(Iop_Sub32, mkexpr(t0), mkU32(8*4)) );
14104 putIReg(4, R_ESP, mkexpr(t5));
14107 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(28)), getIReg(4,R_EAX) );
14108 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(24)), getIReg(4,R_ECX) );
14109 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(20)), getIReg(4,R_EDX) );
14110 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(16)), getIReg(4,R_EBX) );
14111 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32(12)), mkexpr(t0) /*esp*/);
14112 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 8)), getIReg(4,R_EBP) );
14113 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 4)), getIReg(4,R_ESI) );
14114 storeLE( binop(Iop_Add32,mkexpr(t5),mkU32( 0)), getIReg(4,R_EDI) );
14184 assign( t1, binop(Iop_And32, mkexpr(t0),
14189 assign( t1, binop(Iop_Or32, mkexpr(t0),
14194 assign( t1, binop(Iop_Xor32, mkexpr(t0),
14203 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t1) ));
14216 binop(Iop_Shl32, mkexpr(t0), mkU8(31)),
14218 putIReg(1, R_EAX, unop(Iop_32to8, mkexpr(t1)) );
14354 putIReg(sz, gregOfRM(modrm), mkexpr(t1));
14355 putIReg(sz, eregOfRM(modrm), mkexpr(t2));
14363 assign( t1, loadLE(ty,mkexpr(addr)) );
14365 casLE( mkexpr(addr),
14366 mkexpr(t1), mkexpr(t2), guest_EIP_curr_instr );
14367 putIReg( sz, gregOfRM(modrm), mkexpr(t1) );
14446 mkIRExprVec_2( mkexpr(t1), mkU32(sz) )
14450 putIReg(sz, R_EAX, narrowTo( ty, mkexpr(t2) ) );
14492 mkIRExprVec_3( mkexpr(t1),
14689 putIReg(4, opc-0xC8, mkexpr(t2));
14772 Iend_LE, mkexpr(addr),
14773 mkexpr(expdHi), mkexpr(expdLo),
14774 mkexpr(dataHi), mkexpr(dataLo)
14781 binop(Iop_Xor32, mkexpr(oldHi), mkexpr(expdHi)),
14782 binop(Iop_Xor32, mkexpr(oldLo), mkexpr(expdLo))
14794 IRExpr_ITE( mkexpr(success),
14795 mkexpr(expdHi), mkexpr(oldHi)
14798 IRExpr_ITE( mkexpr(success),
14799 mkexpr(expdLo), mkexpr(oldLo)
14808 binop(Iop_And32, mkexpr(flags_old),
14812 unop(Iop_1Uto32, mkexpr(success)), mkU32(1)),
14816 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(flags_new) ));
15075 putIReg(4, R_EDX, unop(Iop_64HIto32, mkexpr(val)));
15076 putIReg(4, R_EAX, unop(Iop_64to32, mkexpr(val)));
15115 putIReg(1, eregOfRM(modrm), mkexpr(t1));
15121 storeLE( mkexpr(addr), mkexpr(t1) );
15322 mkIRExprVec_2( mkexpr(addr),
15327 d->mAddr = mkexpr(addr);