Lines Matching defs:assign
243 static void assign ( IRTemp dst, IRExpr* e )
1478 assign(expTmp, expVal);
1874 assign( oldc, binop(Iop_And64,
1878 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1880 assign( tres, binop(plus,
1933 assign( oldc, binop(Iop_And64,
1937 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
1939 assign( tres, binop(minus,
2212 //.. assign( seg_selector, unop(Iop_16Uto32, getSReg(sreg)) );
2213 //.. assign( ldt_ptr, IRExpr_Get( OFFB_LDT, hWordTy ));
2214 //.. assign( gdt_ptr, IRExpr_Get( OFFB_GDT, hWordTy ));
2221 //.. assign(
2270 assign( tmp, addr64 );
2691 assign( dst0, getIRegG(size,pfx,rm) );
2692 assign( src, getIRegE(size,pfx,rm) );
2704 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2720 assign( dst0, getIRegG(size,pfx,rm) );
2721 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
2733 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2805 assign(dst0, getIRegE(size,pfx,rm));
2806 assign(src, getIRegG(size,pfx,rm));
2818 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2836 assign(dst0, loadLE(ty,mkexpr(addr)));
2837 assign(src, getIRegG(size,pfx,rm));
2861 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
2993 assign(dst0, getIRegRAX(size));
2994 assign(src, mkU(ty,lit & mkSizeMask(size)));
2997 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3003 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3078 assign( src128, binop(Iop_64HLto128,
3081 assign( dst128, binop(op, mkexpr(src128), mkexpr(t)) );
3091 assign( src64,
3093 assign( dst64,
3101 assign( src64, unop(widen3264,
3105 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
3114 assign( src64, unop(widen3264,
3116 assign( dst64,
3162 assign(dst0, getIRegE(sz,pfx,modrm));
3163 assign(src, mkU(ty,d64 & mask));
3173 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3190 assign(dst0, loadLE(ty,mkexpr(addr)));
3191 assign(src, mkU(ty,d64 & mask));
3215 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3265 assign(dst0, getIRegE(sz, pfx, modrm));
3269 assign(dst0, loadLE(ty,mkexpr(addr)));
3309 assign( old_rflags, widenUto64(mk_amd64g_calculate_rflags_all()) );
3316 assign( new_value,
3331 assign( new_rflags,
3341 assign( dst1, narrowTo(ty, mkexpr(new_value)) );
3380 assign( shift_amt, binop(Iop_And8, shift_expr, mkU8(mask)) );
3383 assign( pre64, op64==Iop_Sar64 ? widenSto64(mkexpr(dst0))
3387 assign( res64, binop(op64, mkexpr(pre64), mkexpr(shift_amt)) );
3390 assign( res64ss,
3402 assign( dst1, narrowTo(ty, mkexpr(res64)) );
3420 assign(rot_amt64, binop(Iop_And8, shift_expr, mkU8(mask)));
3423 assign(rot_amt, mkexpr(rot_amt64));
3425 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt64), mkU8(8*sz-1)));
3430 assign(dst1,
3447 assign(dst1,
3467 assign(oldFlags, mk_amd64g_calculate_rflags_all());
3564 assign( t2, widenUto64(getIRegE(sz, pfx, modrm)) );
3573 assign( t2, widenUto64(loadLE(ty, mkexpr(t_addr))) );
3584 assign( t2m, binop(Iop_Or64, mkU64(mask), mkexpr(t2)) );
3587 assign( t2m, binop(Iop_And64, mkU64(mask), mkexpr(t2)) );
3590 assign( t2m, binop(Iop_Xor64, mkU64(mask), mkexpr(t2)) );
3641 assign( t1, getIRegRAX(sz) );
3651 assign( res128, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3652 assign( resHi, unop(Iop_128HIto64,mkexpr(res128)));
3653 assign( resLo, unop(Iop_128to64,mkexpr(res128)));
3665 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3666 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
3667 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
3679 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3680 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
3681 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
3693 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3694 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
3695 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
3729 assign(dst1, binop(mkSizedOp(ty,Iop_And8),
3754 assign(dst0, mkU(ty,0));
3755 assign(src, getIRegE(sz, pfx, modrm));
3756 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
3765 assign(src, getIRegE(sz,pfx,modrm));
3772 assign(src, getIRegE(sz,pfx,modrm));
3778 assign( t1, getIRegE(sz, pfx, modrm) );
3785 assign( t1, getIRegE(sz, pfx, modrm) );
3804 assign(t1, loadLE(ty,mkexpr(addr)));
3810 assign(dst1, binop(mkSizedOp(ty,Iop_And8),
3822 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
3835 assign(dst0, mkU(ty,0));
3836 assign(src, mkexpr(t1));
3837 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
3887 assign(t1, getIRegE(1, pfx, modrm));
3890 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
3895 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
3908 assign( t1, loadLE(ty, mkexpr(addr)) );
3911 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
3921 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
3961 assign(t1, getIRegE(sz,pfx,modrm));
3965 assign(t2, binop(mkSizedOp(ty,Iop_Add8),
3972 assign(t2, binop(mkSizedOp(ty,Iop_Sub8),
3982 assign(t3, getIRegE(sz,pfx,modrm));
3984 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
3997 assign(t3, getIRegE(sz,pfx,modrm));
4014 assign(t1, loadLE(ty,mkexpr(addr)));
4019 assign(t2, binop(mkSizedOp(ty,Iop_Add8),
4031 assign(t2, binop(mkSizedOp(ty,Iop_Sub8),
4046 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4048 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
4061 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4072 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4074 assign( t2, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
4108 assign( t_inc,
4112 assign( t_inc,
4137 assign( td, getIReg64(R_RDI) );
4138 assign( ts, getIReg64(R_RSI) );
4152 assign( ts, getIReg64(R_RSI) );
4166 assign( ta, getIRegRAX(sz) );
4168 assign( td, getIReg64(R_RDI) );
4184 assign( td, getIReg64(R_RDI) );
4186 assign( ts, getIReg64(R_RSI) );
4188 assign( tdv, loadLE(ty,mkexpr(td)) );
4190 assign( tsv, loadLE(ty,mkexpr(ts)) );
4207 assign( ta, getIRegRAX(sz) );
4209 assign( td, getIReg64(R_RDI) );
4211 assign( tdv, loadLE(ty,mkexpr(td)) );
4235 assign( tc, getIReg64(R_RCX) );
4277 assign( tg, getIRegG(size, pfx, rm) );
4279 assign( te, getIRegE(size, pfx, rm) );
4282 assign( te, loadLE(ty,mkexpr(addr)) );
4287 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
4325 assign(te, getIRegE(size, pfx, rm));
4330 assign(te, loadLE(ty, mkexpr(addr)));
4337 assign(tl, mkU(ty,d64));
4339 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
4367 assign(mask[0], mkU16(0x5555));
4368 assign(mask[1], mkU16(0x3333));
4369 assign(mask[2], mkU16(0x0F0F));
4370 assign(mask[3], mkU16(0x00FF));
4374 assign(nyu,
4394 assign(mask[0], mkU32(0x55555555));
4395 assign(mask[1], mkU32(0x33333333));
4396 assign(mask[2], mkU32(0x0F0F0F0F));
4397 assign(mask[3], mkU32(0x00FF00FF));
4398 assign(mask[4], mkU32(0x0000FFFF));
4402 assign(nyu,
4422 assign(mask[0], mkU64(0x5555555555555555ULL));
4423 assign(mask[1], mkU64(0x3333333333333333ULL));
4424 assign(mask[2], mkU64(0x0F0F0F0F0F0F0F0FULL));
4425 assign(mask[3], mkU64(0x00FF00FF00FF00FFULL));
4426 assign(mask[4], mkU64(0x0000FFFF0000FFFFULL));
4427 assign(mask[5], mkU64(0x00000000FFFFFFFFULL));
4431 assign(nyu,
4458 assign(src64, widenUto64( mkexpr(src) ));
4461 assign(src64x,
4468 assign(res64,
4477 assign(res, narrowTo(ty, mkexpr(res64)));
4811 assign( t32, e32 );
5050 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
5077 assign( t64, mkIRExprCCall(
5089 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
5176 assign(t1, get_ST(r_src));
5186 assign(t1, get_ST(0));
5187 assign(t2, get_ST(r_src));
5318 assign( argF, get_ST(0) );
5319 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
5320 assign( sigI,
5328 assign( expI,
5336 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
5337 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
5352 assign( a1, get_ST(0) );
5353 assign( a2, get_ST(1) );
5379 assign( a1, get_ST(0) );
5380 assign( a2, get_ST(1) );
5415 assign( a1, get_ST(0) );
6572 assign(res, binop(op, argL, argR));
6576 assign( res,
6614 assign( amt, getMMXReg(eregLO3ofRM(rm)) );
6621 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
6627 assign( g0, getMMXReg(gregLO3ofRM(rm)) );
6628 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
6645 assign(
6655 assign(
6692 assign( e0, getMMXReg(eregLO3ofRM(rm)) );
6709 assign( e1, amt >= size
6715 assign( e1, amt >= size
7086 assign( addr, handleAddrOverrides( vbi, pfx, getIReg64(R_RDI) ));
7087 assign( regM, getMMXReg( eregLO3ofRM(modrm) ));
7088 assign( regD, getMMXReg( gregLO3ofRM(modrm) ));
7089 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
7090 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
7091 assign( newdata,
7210 assign( gsrc, getIRegG(sz, pfx, modrm) );
7214 assign( esrc, getIRegE(sz, pfx, modrm) );
7224 assign( esrc, loadLE(ty, mkexpr(addr)) );
7235 assign( tmpSH, binop(Iop_And8, shift_amt, mkU8(mask)) );
7236 assign( tmpSS, binop(Iop_And8,
7249 assign( tmp64, binop(Iop_32HLto64, mkexpr(esrc), mkexpr(gsrc)) );
7250 assign( res64,
7254 assign( rss64,
7261 assign( tmp64, binop(Iop_32HLto64, mkexpr(gsrc), mkexpr(esrc)) );
7262 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7263 assign( rss64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSS)) );
7267 assign( tmp64,
7273 assign( res64,
7278 assign( rss64,
7288 assign( tmp64,
7294 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7296 assign( rss64, binop(Iop_Shr64,
7305 assign( res64, shiftL64_with_extras( esrc, gsrc, tmpSH ));
7306 assign( rss64, shiftL64_with_extras( esrc, gsrc, tmpSS ));
7308 assign( res64, shiftR64_with_extras( gsrc, esrc, tmpSH ));
7309 assign( rss64, shiftR64_with_extras( gsrc, esrc, tmpSS ));
7316 assign( resTy, narrowTo(ty, mkexpr(res64)) );
7317 assign( rssTy, narrowTo(ty, mkexpr(rss64)) );
7375 assign( t_bitno0, widenSto64(getIRegG(sz, pfx, modrm)) );
7397 assign( t_rsp, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(288)) );
7403 assign( t_addr0, mkexpr(t_rsp) );
7407 assign( t_bitno1, binop(Iop_And64,
7414 assign( t_bitno1, mkexpr(t_bitno0) );
7423 assign( t_addr1,
7430 assign( t_bitno2,
7438 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
7443 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
7448 assign( t_new,
7452 assign( t_new,
7456 assign( t_new,
7530 assign( src, getIRegE(sz, pfx, modrm) );
7535 assign( src, loadLE(ty, mkexpr(addr)) );
7544 assign( src64, widenUto64(mkexpr(src)) );
7548 assign( src8,
7597 assign( dst64,
7611 assign( dst, unop(Iop_64to16, mkexpr(dst64)) );
7614 assign( dst, unop(Iop_64to32, mkexpr(dst64)) );
7616 assign( dst, mkexpr(dst64) );
7635 assign( t1, getIReg64(R_RAX) );
7636 assign( t2, getIRegRexB(8, pfx, regLo3) );
7640 assign( t1, getIReg32(R_RAX) );
7641 assign( t2, getIRegRexB(4, pfx, regLo3) );
7663 assign( oldflags, mk_amd64g_calculate_rflags_all() );
7689 assign( flags, mk_amd64g_calculate_rflags_all() );
7736 assign( dest, getIRegE(size, pfx, rm) );
7738 assign( src, getIRegG(size, pfx, rm) );
7739 assign( acc, getIRegRAX(size) );
7741 assign( cond8, unop(Iop_1Uto8, mk_amd64g_calculate_condition(AMD64CondZ)) );
7742 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
7743 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
7753 assign( dest, loadLE(ty, mkexpr(addr)) );
7755 assign( src, getIRegG(size, pfx, rm) );
7756 assign( acc, getIRegRAX(size) );
7758 assign( cond8, unop(Iop_1Uto8, mk_amd64g_calculate_condition(AMD64CondZ)) );
7759 assign( dest2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(src)) );
7760 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
7774 assign( src, getIRegG(size, pfx, rm) );
7775 assign( acc, getIRegRAX(size) );
7781 assign( cond8, unop(Iop_1Uto8, mk_amd64g_calculate_condition(AMD64CondZ)) );
7782 assign( acc2, IRExpr_Mux0X(mkexpr(cond8), mkexpr(dest), mkexpr(acc)) );
7827 assign( tmps, getIRegE(sz, pfx, rm) );
7828 assign( tmpd, getIRegG(sz, pfx, rm) );
7845 assign( tmps, loadLE(ty, mkexpr(addr)) );
7846 assign( tmpd, getIRegG(sz, pfx, rm) );
7890 assign( tmpd, getIRegE(sz, pfx, rm) );
7891 assign( tmpt0, getIRegG(sz, pfx, rm) );
7892 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
7906 assign( tmpd, loadLE(ty, mkexpr(addr)) );
7907 assign( tmpt0, getIRegG(sz, pfx, rm) );
7908 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
7921 assign( tmpd, loadLE(ty, mkexpr(addr)) );
7922 assign( tmpt0, getIRegG(sz, pfx, rm) );
7923 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
7999 //.. assign( t1, getSReg(sreg) );
8000 //.. assign( ta, binop(Iop_Sub32, getIReg(4, R_ESP), mkU32(sz)) );
8014 //.. assign( ta, getIReg(4, R_ESP) );
8015 //.. assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
8028 assign(t1, getIReg64(R_RSP));
8029 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
8030 assign(t3, binop(Iop_Add64, mkexpr(t1), mkU64(8+d64)));
8125 assign( epart, unop( Iop_32UtoV128,
8161 assign( epart, unop( Iop_64UtoV128,
8221 assign( oldG0, getXMMReg(gregOfRexRM(pfx,rm)) );
8224 assign( oldG1,
8235 assign( oldG1,
8265 assign( oldG0, getXMMReg(gregOfRexRM(pfx,rm)) );
8268 assign( oldG1,
8279 assign( oldG1,
8400 assign( plain, binop(op, getXMMReg(gregOfRexRM(pfx,rm)),
8411 assign( plain,
8462 assign( amt, getXMMRegLane32(eregOfRexRM(pfx,rm), 0) );
8469 assign( amt, loadLE(Ity_I32, mkexpr(addr)) );
8475 assign( g0, getXMMReg(gregOfRexRM(pfx,rm)) );
8476 assign( amt8, unop(Iop_32to8, mkexpr(amt)) );
8493 assign(
8504 assign(
8541 assign( e0, getXMMReg(eregOfRexRM(pfx,rm)) );
8558 assign( e1, amt >= size
8564 assign( e1, amt >= size
8604 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
8605 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
8616 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
8617 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
8618 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
8619 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
8643 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
8644 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
8655 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
8656 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
8657 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
8658 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
8690 assign(aa, aax);
8691 assign(bb, bbx);
8692 assign( aahi32s,
8696 assign( aalo32s,
8700 assign( bbhi32s,
8704 assign( bblo32s,
8708 assign(one32x2, mkU64( (1ULL << 32) + 1 ));
8709 assign(
8725 assign(
8770 assign( aa, aax );
8771 assign( bb, bbx );
8772 assign( zero, mkU64(0) );
8773 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
8774 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
8775 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
8810 assign( aa, aax );
8811 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
8812 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
8813 assign( zero, mkU64(0) );
8814 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
9089 assign(t1, getIRegRAX(8));
9091 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
9404 assign( argR, getXMMRegLane32F( eregOfRexRM(pfx,modrm),
9412 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
9418 assign( argL, getXMMRegLane32F( gregOfRexRM(pfx,modrm),
9446 assign( arg64, getMMXReg(eregLO3ofRM(modrm)) );
9452 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9458 assign( rmode, get_sse_roundingmode() );
9484 assign( rmode, get_sse_roundingmode() );
9490 assign( arg32, getIReg32(eregOfRexRM(pfx,modrm)) );
9496 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
9510 assign( arg64, getIReg64(eregOfRexRM(pfx,modrm)) );
9516 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
9548 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
9549 assign(f32hi, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 1));
9555 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
9556 assign(f32hi, loadLE(Ity_F32, binop( Iop_Add64,
9566 assign(rmode, mkU32((UInt)Irrm_ZERO) );
9568 assign( rmode, get_sse_roundingmode() );
9571 assign(
9610 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
9616 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
9624 assign( rmode, mkU32((UInt)Irrm_ZERO) );
9626 assign( rmode, get_sse_roundingmode() );
9679 assign( t64, mkIRExprCCall(
9692 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
9905 assign( t0, binop( Iop_And32,
9908 assign( t1, binop( Iop_And32,
9911 assign( t2, binop( Iop_And32,
9914 assign( t3, binop( Iop_And32,
10064 assign(sV, getMMXReg(eregLO3ofRM(modrm)));
10067 case 0: assign(t5, mkexpr(t0)); break;
10068 case 1: assign(t5, mkexpr(t1)); break;
10069 case 2: assign(t5, mkexpr(t2)); break;
10070 case 3: assign(t5, mkexpr(t3)); break;
10107 assign(t5, getMMXReg(gregLO3ofRM(modrm)));
10111 assign(t4, getIReg16(eregOfRexRM(pfx,modrm)));
10121 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
10128 case 0: assign(t6, mk64from16s(t3,t2,t1,t4)); break;
10129 case 1: assign(t6, mk64from16s(t3,t2,t4,t0)); break;
10130 case 2: assign(t6, mk64from16s(t3,t4,t1,t0)); break;
10131 case 3: assign(t6, mk64from16s(t4,t2,t1,t0)); break;
10189 assign(t0, getMMXReg(eregLO3ofRM(modrm)));
10190 assign(t1, mkIRExprCCall(
10264 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
10273 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
10283 assign(dV,
10347 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
10350 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10359 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10454 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
10457 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10464 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10550 assign( argR, getXMMRegLane64F( eregOfRexRM(pfx,modrm),
10558 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
10564 assign( argL, getXMMRegLane64F( gregOfRexRM(pfx,modrm),
10588 assign( arg64, getXMMRegLane64(eregOfRexRM(pfx,modrm), 0) );
10594 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
10622 assign( argV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10628 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10634 assign( rmode, get_sse_roundingmode() );
10666 assign( argV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10673 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10681 assign(rmode, mkU32((UInt)Irrm_ZERO) );
10683 assign( rmode, get_sse_roundingmode() );
10688 assign( t0, unop(Iop_ReinterpI64asF64,
10690 assign( t1, unop(Iop_ReinterpI64asF64,
10724 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
10725 assign(f64hi, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 1));
10731 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
10732 assign(f64hi, loadLE(Ity_F64, binop( Iop_Add64,
10742 assign(rmode, mkU32((UInt)Irrm_ZERO) );
10744 assign( rmode, get_sse_roundingmode() );
10747 assign(
10772 assign( argV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10778 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10784 assign( rmode, get_sse_roundingmode() );
10787 assign( t0, unop(Iop_ReinterpI64asF64,
10789 assign( t1, unop(Iop_ReinterpI64asF64,
10821 assign( arg64, getMMXReg(eregLO3ofRM(modrm)) );
10827 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
10860 assign( argV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10866 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10873 assign( rmode, mkU32((UInt)Irrm_ZERO) );
10875 assign( rmode, get_sse_roundingmode() );
10907 assign( f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0) );
10908 assign( f32hi, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 1) );
10914 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
10915 assign( f32hi, loadLE(Ity_F32,
10953 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
10959 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
10967 assign( rmode, mkU32((UInt)Irrm_ZERO) );
10969 assign( rmode, get_sse_roundingmode() );
10994 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
10999 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
11005 assign( rmode, get_sse_roundingmode() );
11025 assign( arg32, getIReg32(eregOfRexRM(pfx,modrm)) );
11031 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
11043 assign( arg64, getIReg64(eregOfRexRM(pfx,modrm)) );
11049 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11077 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
11082 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
11438 assign( t0, binop( Iop_And32,
11441 assign( t1, binop( Iop_And32,
11466 assign( addr, handleAddrOverrides( vbi, pfx, getIReg64(R_RDI) ));
11467 assign( regD, getXMMReg( gregOfRexRM(pfx,modrm) ));
11472 assign(
11481 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
11482 assign( newdata,
11665 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
11668 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
11676 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11684 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
11685 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
11686 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
11687 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
11749 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
11752 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
11759 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11766 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
11767 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
11768 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
11769 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
11974 assign(t5, getXMMReg(eregOfRexRM(pfx,modrm)));
11977 case 0: assign(t4, unop(Iop_32to16, mkexpr(t0))); break;
11978 case 1: assign(t4, unop(Iop_32HIto16, mkexpr(t0))); break;
11979 case 2: assign(t4, unop(Iop_32to16, mkexpr(t1))); break;
11980 case 3: assign(t4, unop(Iop_32HIto16, mkexpr(t1))); break;
11981 case 4: assign(t4, unop(Iop_32to16, mkexpr(t2))); break;
11982 case 5: assign(t4, unop(Iop_32HIto16, mkexpr(t2))); break;
11983 case 6: assign(t4, unop(Iop_32to16, mkexpr(t3))); break;
11984 case 7: assign(t4, unop(Iop_32HIto16, mkexpr(t3))); break;
12009 assign(t4, getIReg16(eregOfRexRM(pfx,modrm)));
12020 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
12045 assign( s1V, getXMMReg(eregOfRexRM(pfx,modrm)) );
12051 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
12056 assign( s2V, getXMMReg(gregOfRexRM(pfx,modrm)) );
12057 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
12058 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
12059 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
12060 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
12061 assign( dHi, mkIRExprCCall(
12067 assign( dLo, mkIRExprCCall(
12073 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
12122 assign(t0, getXMMRegLane64(eregOfRexRM(pfx,modrm), 0));
12123 assign(t1, getXMMRegLane64(eregOfRexRM(pfx,modrm), 1));
12125 assign(t5, mkIRExprCCall(
12175 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
12178 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
12184 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
12190 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
12191 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
12212 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
12215 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
12221 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12230 assign( t0, binop( Iop_MullU32, mkexpr(d0), mkexpr(s0)) );
12232 assign( t1, binop( Iop_MullU32, mkexpr(d2), mkexpr(s2)) );
12259 assign( s1V, getXMMReg(eregOfRexRM(pfx,modrm)) );
12265 assign( s1V, loadLE(Ity_V128, mkexpr(addr)) );
12270 assign( s2V, getXMMReg(gregOfRexRM(pfx,modrm)) );
12271 assign( s1Hi, unop(Iop_V128HIto64, mkexpr(s1V)) );
12272 assign( s1Lo, unop(Iop_V128to64, mkexpr(s1V)) );
12273 assign( s2Hi, unop(Iop_V128HIto64, mkexpr(s2V)) );
12274 assign( s2Lo, unop(Iop_V128to64, mkexpr(s2V)) );
12275 assign( dHi, mkIRExprCCall(
12281 assign( dLo, mkIRExprCCall(
12287 assign( dV, binop(Iop_64HLtoV128, mkexpr(dHi), mkexpr(dLo))) ;
12302 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
12311 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12322 assign(dV,
12344 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
12353 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12360 assign( sVhi, unop(Iop_V128HIto64, mkexpr(sV)) );
12365 assign(dVhi,
12369 assign(dV, binop( Iop_64HLtoV128,
12390 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
12399 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12406 assign( sVlo, unop(Iop_V128to64, mkexpr(sV)) );
12411 assign(dVlo,
12415 assign(dV, binop( Iop_64HLtoV128,
12464 assign( sV, getXMMReg(reg) );
12465 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
12466 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
12469 assign( lo64r, mkexpr(lo64) );
12470 assign( hi64r, mkexpr(hi64) );
12474 assign( lo64r, mkU64(0) );
12475 assign( hi64r, mkexpr(lo64) );
12479 assign( lo64r, mkU64(0) );
12480 assign( hi64r, binop( Iop_Shl64,
12484 assign( lo64r, binop( Iop_Shl64,
12487 assign( hi64r,
12496 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
12606 assign( sV, getXMMReg(reg) );
12607 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
12608 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
12611 assign( lo64r, mkexpr(lo64) );
12612 assign( hi64r, mkexpr(hi64) );
12616 assign( hi64r, mkU64(0) );
12617 assign( lo64r, mkexpr(hi64) );
12621 assign( hi64r, mkU64(0) );
12622 assign( lo64r, binop( Iop_Shr64,
12626 assign( hi64r, binop( Iop_Shr64,
12629 assign( lo64r,
12639 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
12899 assign( sV, getXMMReg( eregOfRexRM(pfx,modrm)) );
12907 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12931 assign( sV, getXMMReg( eregOfRexRM(pfx,modrm)) );
12935 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
12938 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
12961 assign( eV, getXMMReg( eregOfRexRM(pfx,modrm)) );
12967 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
12973 assign( gV, getXMMReg(gregOfRexRM(pfx,modrm)) );
12975 assign( addV, binop(Iop_Add32Fx4, mkexpr(gV), mkexpr(eV)) );
12976 assign( subV, binop(Iop_Sub32Fx4, mkexpr(gV), mkexpr(eV)) );
12997 assign( eV, getXMMReg( eregOfRexRM(pfx,modrm)) );
13003 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
13009 assign( gV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13011 assign( addV, binop(Iop_Add64Fx2, mkexpr(gV), mkexpr(eV)) );
13012 assign( subV, binop(Iop_Sub64Fx2, mkexpr(gV), mkexpr(eV)) );
13014 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
13015 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
13037 assign( eV, getXMMReg( eregOfRexRM(pfx,modrm)) );
13043 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
13049 assign( gV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13054 assign( leftV, mk128from32s( e2, e0, g2, g0 ) );
13055 assign( rightV, mk128from32s( e3, e1, g3, g1 ) );
13080 assign( eV, getXMMReg( eregOfRexRM(pfx,modrm)) );
13086 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
13092 assign( gV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13094 assign( e1, unop(Iop_V128HIto64, mkexpr(eV) ));
13095 assign( e0, unop(Iop_V128to64, mkexpr(eV) ));
13096 assign( g1, unop(Iop_V128HIto64, mkexpr(gV) ));
13097 assign( g0, unop(Iop_V128to64, mkexpr(gV) ));
13099 assign( leftV, binop(Iop_64HLtoV128, mkexpr(e0),mkexpr(g0)) );
13100 assign( rightV, binop(Iop_64HLtoV128, mkexpr(e1),mkexpr(g1)) );
13147 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13150 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13156 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13163 assign( sVoddsSX,
13165 assign( sVevensSX,
13169 assign( dVoddsZX,
13171 assign( dVevensZX,
13199 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13202 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13209 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13216 assign( sVoddsSX,
13218 assign( sVevensSX,
13222 assign( dVoddsZX,
13224 assign( dVevensZX,
13282 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13285 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13291 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13352 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13355 assign( sV, getXMMReg( eregOfRexRM(pfx,modrm)) );
13362 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13368 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
13369 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
13370 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13371 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13402 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13405 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13411 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13437 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13440 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13447 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13453 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
13454 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
13455 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13456 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13489 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13492 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13498 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13535 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13538 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13545 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13551 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
13552 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
13553 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13554 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13588 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13594 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13630 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13637 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13643 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13644 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13665 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13668 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13676 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13685 assign( res, mkexpr(sV) );
13688 assign(res,
13695 assign( res, mkexpr(dV) );
13698 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d64-8))) );
13701 assign( res, mkU64(0) );
13724 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13727 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13736 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13744 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
13745 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
13746 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13747 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13750 assign( rHi, mkexpr(sHi) );
13751 assign( rLo, mkexpr(sLo) );
13754 assign( rHi, dis_PALIGNR_XMM_helper(dLo, sHi, d64) );
13755 assign( rLo, dis_PALIGNR_XMM_helper(sHi, sLo, d64) );
13758 assign( rHi, mkexpr(dLo) );
13759 assign( rLo, mkexpr(sHi) );
13762 assign( rHi, dis_PALIGNR_XMM_helper(dHi, dLo, d64-8) );
13763 assign( rLo, dis_PALIGNR_XMM_helper(dLo, sHi, d64-8) );
13766 assign( rHi, mkexpr(dHi) );
13767 assign( rLo, mkexpr(dLo) );
13770 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d64-16))) );
13771 assign( rLo, dis_PALIGNR_XMM_helper(dHi, dLo, d64-16) );
13774 assign( rHi, mkU64(0) );
13775 assign( rLo, mkexpr(dHi) );
13778 assign( rHi, mkU64(0) );
13779 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(d64-24))) );
13782 assign( rHi, mkU64(0) );
13783 assign( rLo, mkU64(0) );
13804 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
13807 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13813 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13859 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13862 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13869 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13875 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
13876 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
13877 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
13878 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
13880 assign( sevens, mkU64(0x0707070707070707ULL) );
13890 assign(
13894 assign(
13900 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
13902 assign(
13913 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
13917 assign(
13921 assign(
13927 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
13929 assign(
13940 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
13971 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
13975 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
13984 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
13998 assign( imm8_mask, mkV128( imm8_mask_16 ) );
14022 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14026 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14035 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
14046 assign( imm8_mask, mkV128( imm8_perms[ (imm8 & 15) ] ) );
14070 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14074 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14083 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
14099 assign( imm16_mask, mkV128( imm16 ));
14125 assign( dvec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14129 assign( svec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14138 assign( svec, loadLE( Ity_V128, mkexpr(addr) ) );
14147 assign(t0, unop((imm8&1)? Iop_V128HIto64 : Iop_V128to64, mkexpr(dvec)));
14148 assign(t1, unop((imm8&16) ? Iop_V128HIto64 : Iop_V128to64, mkexpr(svec)));
14156 assign(t2,
14160 assign(t3,
14165 assign(res, binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)));
14185 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14189 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14198 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
14207 assign( and_vec, binop( Iop_AndV128,
14212 assign( sum_vec, binop( Iop_Add64F0x2,
14247 assign( xmm1_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14251 assign( xmm2_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14260 assign( xmm2_vec, loadLE( Ity_V128, mkexpr(addr) ) );
14271 assign( tmp_prod_vec,
14276 assign( prod_vec, mk128from32s( v3, v1, v2, v0 ) );
14278 assign( sum_vec, binop( Iop_Add32Fx4,
14312 assign( dstVec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
14316 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14328 case 0: assign( srcDWord, mkexpr(src_lane_0) ); break;
14329 case 1: assign( srcDWord, mkexpr(src_lane_1) ); break;
14330 case 2: assign( srcDWord, mkexpr(src_lane_2) ); break;
14331 case 3: assign( srcDWord, mkexpr(src_lane_3) ); break;
14342 assign( srcDWord, loadLE( Ity_I32, mkexpr(addr) ) );
14368 assign( zero_32, mkU32(0) );
14394 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
14404 case 0: assign( sel_lane, mkexpr(t0) ); break;
14405 case 1: assign( sel_lane, mkexpr(t1) ); break;
14406 case 2: assign( sel_lane, mkexpr(t2) ); break;
14407 case 3: assign( sel_lane, mkexpr(t3) ); break;
14410 assign( shr_lane,
14446 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
14457 case 0: assign( src_dword, mkexpr(t0) ); break;
14458 case 1: assign( src_dword, mkexpr(t1) ); break;
14459 case 2: assign( src_dword, mkexpr(t2) ); break;
14460 case 3: assign( src_dword, mkexpr(t3) ); break;
14494 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
14503 case 0: assign( src_qword, unop(Iop_V128to64, mkexpr(xmm_vec)) ); break;
14504 case 1: assign( src_qword, unop(Iop_V128HIto64, mkexpr(xmm_vec)) ); break;
14536 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
14547 case 0: assign( src_word, unop(Iop_32to16, mkexpr(t0)) ); break;
14548 case 1: assign( src_word, unop(Iop_32HIto16, mkexpr(t0)) ); break;
14549 case 2: assign( src_word, unop(Iop_32to16, mkexpr(t1)) ); break;
14550 case 3: assign( src_word, unop(Iop_32HIto16, mkexpr(t1)) ); break;
14551 case 4: assign( src_word, unop(Iop_32to16, mkexpr(t2)) ); break;
14552 case 5: assign( src_word, unop(Iop_32HIto16, mkexpr(t2)) ); break;
14553 case 6: assign( src_word, unop(Iop_32to16, mkexpr(t3)) ); break;
14554 case 7: assign( src_word, unop(Iop_32HIto16, mkexpr(t3)) ); break;
14589 assign( src_elems, getIReg64( eregOfRexRM(pfx,modrm) ) );
14597 assign( src_elems, loadLE( Ity_I64, mkexpr(addr) ) );
14606 assign( src_vec, binop( Iop_64HLtoV128, mkU64(0), mkexpr(src_elems) ) );
14609 assign( src_vec, binop( Iop_64HLtoV128, mkexpr(src_elems), mkU64(0) ) );
14637 assign( src_elems, getIReg32( eregOfRexRM(pfx,modrm) ) );
14645 assign( src_elems, loadLE( Ity_I32, mkexpr(addr) ) );
14651 assign(z32, mkU32(0));
14656 assign(src_vec, mk128from32s(src_elems, z32, z32, z32));
14659 assign(src_vec, mk128from32s(z32, src_elems, z32, z32));
14662 assign(src_vec, mk128from32s(z32, z32, src_elems, z32));
14665 assign(src_vec, mk128from32s(z32, z32, z32, src_elems));
14692 assign( new8, binop(Iop_And64,
14703 assign( new8, unop(Iop_8Uto64, loadLE( Ity_I8, mkexpr(addr) )));
14713 assign(halfshift, binop(Iop_Shl64,
14717 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
14719 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
14748 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
14759 case 0: assign( src_dword, mkexpr(t0) ); break;
14760 case 1: assign( src_dword, mkexpr(t1) ); break;
14761 case 2: assign( src_dword, mkexpr(t2) ); break;
14762 case 3: assign( src_dword, mkexpr(t3) ); break;
14879 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14886 assign( srcVec,
14917 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
14924 assign( srcVec,
14932 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
14959 assign( srcBytes, getXMMRegLane16( eregOfRexRM(pfx, modrm), 0 ) );
14966 assign( srcBytes, loadLE( Ity_I16, mkexpr(addr) ) );
14995 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15002 assign( srcVec,
15033 assign( srcBytes, getXMMRegLane32( eregOfRexRM(pfx, modrm), 0 ) );
15040 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
15068 assign( srcBytes, getXMMRegLane64( eregOfRexRM(pfx, modrm), 0 ) );
15075 assign( srcBytes, loadLE( Ity_I64, mkexpr(addr) ) );
15103 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15110 assign( srcVec,
15136 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15143 assign( srcVec,
15151 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
15174 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15181 assign( srcVec,
15190 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
15215 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15222 assign( srcVec,
15249 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15256 assign( srcVec,
15264 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
15287 assign( srcVec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15294 assign( srcVec,
15322 assign( argL, getXMMReg( eregOfRexRM(pfx, modrm) ) );
15330 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
15336 assign(argR, getXMMReg( gregOfRexRM(pfx, modrm) ));
15355 assign(src, getIRegE(sz, pfx, modrm));
15361 assign(src, loadLE(ty, mkexpr(addr)));
15404 assign( src,
15416 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
15429 assign(res, binop(isD ? Iop_RoundF64toInt : Iop_RoundF32toInt,
15458 assign( src0,
15460 assign( src1,
15471 assign( src0, loadLE(Ity_F64,
15473 assign( src1, loadLE(Ity_F64,
15486 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
15488 assign(res0, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src0)) );
15489 assign(res1, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src1)) );
15517 assign( src0,
15519 assign( src1,
15521 assign( src2,
15523 assign( src3,
15534 assign( src0, loadLE(Ity_F32,
15536 assign( src1, loadLE(Ity_F32,
15538 assign( src2, loadLE(Ity_F32,
15540 assign( src3, loadLE(Ity_F32,
15553 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
15555 assign(res0, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src0)) );
15556 assign(res1, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src1)) );
15557 assign(res2, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src2)) );
15558 assign(res3, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src3)) );
15581 assign(src, getIRegE(sz, pfx, modrm));
15587 assign(src, loadLE(ty, mkexpr(addr)));
15602 assign(src64, widenUto64(mkexpr(src)));
15603 assign(res64, widenUto64(mkexpr(res)));
15606 assign(
15764 assign(vecE, getXMMReg(eregOfRexRM(pfx, modrm)));
15772 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
15778 assign(vecG, getXMMReg(gregOfRexRM(pfx, modrm)));
15787 assign(andV, binop(Iop_AndV128, mkexpr(vecE), mkexpr(vecG)));
15788 assign(andnV, binop(Iop_AndV128,
15807 assign(
15817 assign(
15834 assign(z64,
15844 assign(c64,
15857 assign(newOSZACP,
15904 assign(vecE, getXMMReg(eregOfRexRM(pfx, modrm)));
15912 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
15918 assign(vecG, getXMMReg(gregOfRexRM(pfx, modrm)));
15919 assign(vec0, getXMMReg(0));
15925 assign(sh, mkU8(8 * gran - 1));
15928 assign(mask, binop(opSAR, mkexpr(vec0), mkexpr(sh)));
15931 assign(notmask, unop(Iop_NotV128, mkexpr(mask)));
15960 assign(valE, getIRegE(sz, pfx, modrm));
15966 assign(valE, loadLE(tyE, mkexpr(addr)));
15977 assign(valG0, binop(Iop_And64, getIRegG(8, pfx, modrm),
15994 assign(valG1,
16042 assign(t1, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
16046 assign(t2, mkU64((Addr64)d64));
16090 assign(t1, getIReg64(R_RBP));
16094 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
16535 assign( addr, handleAddrOverrides(vbi, pfx, mkU64(d64)) );
16553 assign( addr, handleAddrOverrides(vbi, pfx, mkU64(d64)) );
16920 assign(t2, getIReg64(R_RSP));
16921 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
16935 assign(t2, getIReg64(R_RSP));
16936 assign(t1, widenUto64(loadLE(szToITy(sz),mkexpr(t2))));
17001 //.. assign( t5, getIReg(4, R_ESP) );
17040 assign( t1, getIReg64(R_RSP) );
17041 assign( t3, loadLE(Ity_I64, mkexpr(t1)) );
17086 assign(t1, getIRegRexB(sz, pfx, opc-0x50));
17087 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(sz)));
17110 assign( t1, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
17131 assign( t1, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
17135 assign( t2, mk_amd64g_calculate_rflags_all() );
17140 assign( t3, binop(Iop_Or64,
17149 assign( t4, binop(Iop_Or64,
17159 assign( t5, binop(Iop_Or64,
17188 //.. assign( t0, getIReg(4, R_ESP) );
17192 //.. assign( t5, binop(Iop_Sub32, mkexpr(t0), mkU32(8*4)) );
17261 assign( t0, mk_amd64g_calculate_rflags_all() );
17264 assign( t1, binop(Iop_And64, mkexpr(t0),
17269 assign( t1, binop(Iop_Or64, mkexpr(t0),
17274 assign( t1, binop(Iop_Xor64, mkexpr(t0),
17444 assign(t1, getIRegE(sz, pfx, modrm));
17445 assign(t2, getIRegG(sz, pfx, modrm));
17455 assign( t1, loadLE(ty, mkexpr(addr)) );
17456 assign( t2, getIRegG(sz, pfx, modrm) );
17525 assign(t1, mkU64( abyte & 0xFF ));
17532 assign(t1, mkU64( abyte & 0xFF ));
17538 assign(t1, unop(Iop_16Uto64, getIRegRDX(2)));
17545 assign(t1, unop(Iop_16Uto64, getIRegRDX(2)));
17574 assign( t1, mkU64( abyte & 0xFF ) );
17581 assign( t1, mkU64( abyte & 0xFF ) );
17587 assign( t1, unop(Iop_16Uto64, getIRegRDX(2)) );
17594 assign( t1, unop(Iop_16Uto64, getIRegRDX(2)) );
17808 assign( t1, getIRegRexB(4, pfx, opc-0xC8) );
17809 assign( t2,
17834 assign( t1, getIRegRexB(8, pfx, opc-0xC8) );
17836 assign( m8, mkU64(0xFF00FF00FF00FF00ULL) );
17837 assign( s8,
17848 assign( m16, mkU64(0xFFFF0000FFFF0000ULL) );
17849 assign( s16,
17860 assign( m32, mkU64(0xFFFFFFFF00000000ULL) );
17861 assign( t2,
17985 assign( expdHi64, getIReg64(R_RDX) );
17986 assign( expdLo64, getIReg64(R_RAX) );
17992 assign( expdHi, sz==4 ? unop(Iop_64to32, mkexpr(expdHi64))
17994 assign( expdLo, sz==4 ? unop(Iop_64to32, mkexpr(expdLo64))
17996 assign( dataHi, sz==4 ? getIReg32(R_RCX) : getIReg64(R_RCX) );
17997 assign( dataLo, sz==4 ? getIReg32(R_RBX) : getIReg64(R_RBX) );
18008 assign( success,
18048 assign( flags_old, widenUto64(mk_amd64g_calculate_rflags_all()));
18049 assign(
18334 assign( t1, unop(Iop_1Uto8,mk_amd64g_calculate_condition(opc-0x90)) );
18711 // assign(t[0], binop(Iop_Or64, mkexpr(src),
18713 // assign(t[1], binop(Iop_Or64, mkexpr(t[0]),
18715 // assign(t[2], binop(Iop_Or64, mkexpr(t[1]),
18717 // assign(t[3], binop(Iop_Or64, mkexpr(t[2]),
18719 // assign(t[4], binop(Iop_Or64, mkexpr(t[3]),
18721 // assign(t[5], binop(Iop_Or64, mkexpr(t[4]),
18723 // assign(t[6], unop(Iop_Not64, mkexpr(t[5])));
18727 // assign(t[0], binop(Iop_Or32, mkexpr(src),
18729 // assign(t[1], binop(Iop_Or32, mkexpr(t[0]),
18731 // assign(t[2], binop(Iop_Or32, mkexpr(t[1]),
18733 // assign(t[3], binop(Iop_Or32, mkexpr(t[2]),
18735 // assign(t[4], binop(Iop_Or32, mkexpr(t[3]),
18737 // assign(t[5], unop(Iop_Not32, mkexpr(t[4])));
18741 // assign(t[0], binop(Iop_Or16, mkexpr(src),
18743 // assign(t[1], binop(Iop_Or16, mkexpr(t[0]),
18745 // assign(t[2], binop(Iop_Or16, mkexpr(t[1]),
18747 // assign(t[3], binop(Iop_Or16, mkexpr(t[2]),
18749 // assign(t[4], unop(Iop_Not16, mkexpr(t[3])));
