Lines Matching refs:assign
238 static void assign ( IRTemp dst, IRExpr* e )
1614 assign(expTmp, expVal);
1857 assign( guardB, binop(Iop_CmpNE8, mkexpr(guard), mkU8(0)) );
2016 assign( oldc, binop(Iop_And64,
2020 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
2022 assign( tres, binop(plus,
2075 assign( oldc, binop(Iop_And64,
2079 assign( oldcn, narrowTo(ty, mkexpr(oldc)) );
2081 assign( tres, binop(minus,
2384 //.. assign( seg_selector, unop(Iop_16Uto32, getSReg(sreg)) );
2385 //.. assign( ldt_ptr, IRExpr_Get( OFFB_LDT, hWordTy ));
2386 //.. assign( gdt_ptr, IRExpr_Get( OFFB_GDT, hWordTy ));
2393 //.. assign(
2442 assign( tmp, addr64 );
2945 assign( dst0, getIRegG(size,pfx,rm) );
2946 assign( src, getIRegE(size,pfx,rm) );
2958 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
2974 assign( dst0, getIRegG(size,pfx,rm) );
2975 assign( src, loadLE(szToITy(size), mkexpr(addr)) );
2987 assign( dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3059 assign(dst0, getIRegE(size,pfx,rm));
3060 assign(src, getIRegG(size,pfx,rm));
3072 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3090 assign(dst0, loadLE(ty,mkexpr(addr)));
3091 assign(src, getIRegG(size,pfx,rm));
3115 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3254 assign(dst0, getIRegRAX(size));
3255 assign(src, mkU(ty,lit & mkSizeMask(size)));
3258 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3264 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)) );
3339 assign( src128, binop(Iop_64HLto128,
3342 assign( dst128, binop(op, mkexpr(src128), mkexpr(t)) );
3352 assign( src64,
3354 assign( dst64,
3362 assign( src64, unop(widen3264,
3366 assign( dst64, binop(op, mkexpr(src64), unop(widen1632,mkexpr(t))) );
3375 assign( src64, unop(widen3264,
3377 assign( dst64,
3423 assign(dst0, getIRegE(sz,pfx,modrm));
3424 assign(src, mkU(ty,d64 & mask));
3434 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3451 assign(dst0, loadLE(ty,mkexpr(addr)));
3452 assign(src, mkU(ty,d64 & mask));
3476 assign(dst1, binop(mkSizedOp(ty,op8), mkexpr(dst0), mkexpr(src)));
3526 assign(dst0, getIRegE(sz, pfx, modrm));
3530 assign(dst0, loadLE(ty,mkexpr(addr)));
3565 assign( old_rflags, widenUto64(mk_amd64g_calculate_rflags_all()) );
3572 assign( new_value,
3587 assign( new_rflags,
3597 assign( dst1, narrowTo(ty, mkexpr(new_value)) );
3637 assign( shift_amt, binop(Iop_And8, shift_expr, mkU8(mask)) );
3640 assign( pre64, op64==Iop_Sar64 ? widenSto64(mkexpr(dst0))
3644 assign( res64, binop(op64, mkexpr(pre64), mkexpr(shift_amt)) );
3647 assign( res64ss,
3659 assign( dst1, narrowTo(ty, mkexpr(res64)) );
3677 assign(rot_amt64, binop(Iop_And8, shift_expr, mkU8(mask)));
3680 assign(rot_amt, mkexpr(rot_amt64));
3682 assign(rot_amt, binop(Iop_And8, mkexpr(rot_amt64), mkU8(8*sz-1)));
3687 assign(dst1,
3704 assign(dst1,
3724 assign(oldFlags, mk_amd64g_calculate_rflags_all());
3728 assign(rot_amt64b, binop(Iop_CmpNE8, mkexpr(rot_amt64), mkU8(0)) );
3843 assign( t2, widenUto64(getIRegE(sz, pfx, modrm)) );
3852 assign( t2, widenUto64(loadLE(ty, mkexpr(t_addr))) );
3863 assign( t2m, binop(Iop_Or64, mkU64(mask), mkexpr(t2)) );
3866 assign( t2m, binop(Iop_And64, mkU64(mask), mkexpr(t2)) );
3869 assign( t2m, binop(Iop_Xor64, mkU64(mask), mkexpr(t2)) );
3920 assign( t1, getIRegRAX(sz) );
3930 assign( res128, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3931 assign( resHi, unop(Iop_128HIto64,mkexpr(res128)));
3932 assign( resLo, unop(Iop_128to64,mkexpr(res128)));
3944 assign( res64, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3945 assign( resHi, unop(Iop_64HIto32,mkexpr(res64)));
3946 assign( resLo, unop(Iop_64to32,mkexpr(res64)));
3958 assign( res32, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3959 assign( resHi, unop(Iop_32HIto16,mkexpr(res32)));
3960 assign( resLo, unop(Iop_32to16,mkexpr(res32)));
3972 assign( res16, binop(mulOp, mkexpr(t1), mkexpr(tmp)) );
3973 assign( resHi, unop(Iop_16HIto8,mkexpr(res16)));
3974 assign( resLo, unop(Iop_16to8,mkexpr(res16)));
4011 assign(dst1, binop(mkSizedOp(ty,Iop_And8),
4036 assign(dst0, mkU(ty,0));
4037 assign(src, getIRegE(sz, pfx, modrm));
4038 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
4047 assign(src, getIRegE(sz,pfx,modrm));
4054 assign(src, getIRegE(sz,pfx,modrm));
4060 assign( t1, getIRegE(sz, pfx, modrm) );
4067 assign( t1, getIRegE(sz, pfx, modrm) );
4094 assign(t1, loadLE(ty,mkexpr(addr)));
4100 assign(dst1, binop(mkSizedOp(ty,Iop_And8),
4112 assign(dst1, unop(mkSizedOp(ty,Iop_Not8), mkexpr(t1)));
4125 assign(dst0, mkU(ty,0));
4126 assign(src, mkexpr(t1));
4127 assign(dst1, binop(mkSizedOp(ty,Iop_Sub8), mkexpr(dst0),
4183 assign(t1, getIRegE(1, pfx, modrm));
4186 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4191 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4212 assign( t1, loadLE(ty, mkexpr(addr)) );
4215 assign(t2, binop(Iop_Add8, mkexpr(t1), mkU8(1)));
4225 assign(t2, binop(Iop_Sub8, mkexpr(t1), mkU8(1)));
4275 assign(t1, getIRegE(sz,pfx,modrm));
4279 assign(t2, binop(mkSizedOp(ty,Iop_Add8),
4286 assign(t2, binop(mkSizedOp(ty,Iop_Sub8),
4297 assign(t3, getIRegE(sz,pfx,modrm));
4299 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
4313 assign(t3, getIRegE(sz,pfx,modrm));
4324 assign(t3, getIRegE(sz,pfx,modrm));
4326 assign( t2, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
4357 assign(t1, loadLE(ty,mkexpr(addr)));
4362 assign(t2, binop(mkSizedOp(ty,Iop_Add8),
4374 assign(t2, binop(mkSizedOp(ty,Iop_Sub8),
4390 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4392 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
4406 assign(t3, loadLE(Ity_I64,mkexpr(addr)));
4417 assign(t3, loadLE(ty,mkexpr(addr)));
4419 assign( t2, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
4453 assign( t_inc,
4457 assign( t_inc,
4484 assign( td, unop(Iop_32Uto64, getIReg32(R_RDI)) );
4485 assign( ts, unop(Iop_32Uto64, getIReg32(R_RSI)) );
4487 assign( td, getIReg64(R_RDI) );
4488 assign( ts, getIReg64(R_RSI) );
4511 assign( ts, unop(Iop_32Uto64, getIReg32(R_RSI)) );
4513 assign( ts, getIReg64(R_RSI) );
4531 assign( ta, getIRegRAX(sz) );
4534 assign( td, unop(Iop_32Uto64, getIReg32(R_RDI)) );
4536 assign( td, getIReg64(R_RDI) );
4557 assign( td, unop(Iop_32Uto64, getIReg32(R_RDI)) );
4558 assign( ts, unop(Iop_32Uto64, getIReg32(R_RSI)) );
4560 assign( td, getIReg64(R_RDI) );
4561 assign( ts, getIReg64(R_RSI) );
4564 assign( tdv, loadLE(ty,mkexpr(td)) );
4566 assign( tsv, loadLE(ty,mkexpr(ts)) );
4589 assign( ta, getIRegRAX(sz) );
4592 assign( td, unop(Iop_32Uto64, getIReg32(R_RDI)) );
4594 assign( td, getIReg64(R_RDI) );
4596 assign( tdv, loadLE(ty,mkexpr(td)) );
4627 assign( tc, getIReg32(R_RCX) );
4631 assign( tc, getIReg64(R_RCX) );
4680 assign( tg, getIRegG(size, pfx, rm) );
4682 assign( te, getIRegE(size, pfx, rm) );
4685 assign( te, loadLE(ty,mkexpr(addr)) );
4690 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tg) ) );
4728 assign(te, getIRegE(size, pfx, rm));
4733 assign(te, loadLE(ty, mkexpr(addr)));
4740 assign(tl, mkU(ty,d64));
4742 assign( resLo, binop( mkSizedOp(ty, Iop_Mul8), mkexpr(te), mkexpr(tl) ));
4770 assign(mask[0], mkU16(0x5555));
4771 assign(mask[1], mkU16(0x3333));
4772 assign(mask[2], mkU16(0x0F0F));
4773 assign(mask[3], mkU16(0x00FF));
4777 assign(nyu,
4797 assign(mask[0], mkU32(0x55555555));
4798 assign(mask[1], mkU32(0x33333333));
4799 assign(mask[2], mkU32(0x0F0F0F0F));
4800 assign(mask[3], mkU32(0x00FF00FF));
4801 assign(mask[4], mkU32(0x0000FFFF));
4805 assign(nyu,
4825 assign(mask[0], mkU64(0x5555555555555555ULL));
4826 assign(mask[1], mkU64(0x3333333333333333ULL));
4827 assign(mask[2], mkU64(0x0F0F0F0F0F0F0F0FULL));
4828 assign(mask[3], mkU64(0x00FF00FF00FF00FFULL));
4829 assign(mask[4], mkU64(0x0000FFFF0000FFFFULL));
4830 assign(mask[5], mkU64(0x00000000FFFFFFFFULL));
4834 assign(nyu,
4861 assign(src64, widenUto64( mkexpr(src) ));
4864 assign(src64x,
4871 assign(res64,
4879 assign(res, narrowTo(ty, mkexpr(res64)));
4894 assign(src64, widenUto64( mkexpr(src) ));
4899 assign(res64,
4907 assign(res, narrowTo(ty, mkexpr(res64)));
5089 assign(old_tag, get_ST_TAG(i));
5091 assign(new_tag,
5095 assign(old_val, get_ST_UNCHECKED(i));
5097 assign(new_val,
5169 assign(i64, unop(Iop_ReinterpF64asI64, mkexpr(d64)) );
5171 assign(exponent,
5176 assign(in_range_and_finite,
5323 assign( t32, e32 );
5567 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
5595 assign( t64, mkIRExprCCall(
5607 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
5695 assign(t1, get_ST(r_src));
5705 assign(t1, get_ST(0));
5706 assign(t2, get_ST(r_src));
5811 assign(argD, get_ST(0));
5814 assign(resD,
5852 assign( argF, get_ST(0) );
5853 assign( argI, unop(Iop_ReinterpF64asI64, mkexpr(argF)));
5854 assign( sigI,
5862 assign( expI,
5870 assign( sigF, unop(Iop_ReinterpI64asF64, mkexpr(sigI)) );
5871 assign( expF, unop(Iop_ReinterpI64asF64, mkexpr(expI)) );
5886 assign( a1, get_ST(0) );
5887 assign( a2, get_ST(1) );
5913 assign( a1, get_ST(0) );
5914 assign( a2, get_ST(1) );
5950 assign(argD, get_ST(0));
5953 assign(resD,
5995 assign(argD, get_ST(0));
5998 assign(resD,
6570 assign(ew, unop(Iop_64to32,mkexpr(w64)) );
7159 assign(res, binop(op, argL, argR));
7163 assign( res,
7201 assign( amt, getMMXReg(eregLO3ofRM(rm)) );
7208 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
7214 assign( g0, getMMXReg(gregLO3ofRM(rm)) );
7215 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
7232 assign(
7242 assign(
7279 assign( e0, getMMXReg(eregLO3ofRM(rm)) );
7296 assign( e1, amt >= size
7302 assign( e1, amt >= size
7675 assign( addr, handleAddrOverrides( vbi, pfx, getIReg64(R_RDI) ));
7676 assign( regM, getMMXReg( eregLO3ofRM(modrm) ));
7677 assign( regD, getMMXReg( gregLO3ofRM(modrm) ));
7678 assign( mask, binop(Iop_SarN8x8, mkexpr(regM), mkU8(7)) );
7679 assign( olddata, loadLE( Ity_I64, mkexpr(addr) ));
7680 assign( newdata,
7799 assign( gsrc, getIRegG(sz, pfx, modrm) );
7803 assign( esrc, getIRegE(sz, pfx, modrm) );
7813 assign( esrc, loadLE(ty, mkexpr(addr)) );
7824 assign( tmpSH, binop(Iop_And8, shift_amt, mkU8(mask)) );
7825 assign( tmpSS, binop(Iop_And8,
7838 assign( tmp64, binop(Iop_32HLto64, mkexpr(esrc), mkexpr(gsrc)) );
7839 assign( res64,
7843 assign( rss64,
7850 assign( tmp64, binop(Iop_32HLto64, mkexpr(gsrc), mkexpr(esrc)) );
7851 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7852 assign( rss64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSS)) );
7856 assign( tmp64,
7862 assign( res64,
7867 assign( rss64,
7877 assign( tmp64,
7883 assign( res64, binop(Iop_Shr64, mkexpr(tmp64), mkexpr(tmpSH)) );
7885 assign( rss64, binop(Iop_Shr64,
7894 assign( res64, shiftL64_with_extras( esrc, gsrc, tmpSH ));
7895 assign( rss64, shiftL64_with_extras( esrc, gsrc, tmpSS ));
7897 assign( res64, shiftR64_with_extras( gsrc, esrc, tmpSH ));
7898 assign( rss64, shiftR64_with_extras( gsrc, esrc, tmpSS ));
7905 assign( resTy, narrowTo(ty, mkexpr(res64)) );
7906 assign( rssTy, narrowTo(ty, mkexpr(rss64)) );
7983 assign( t_bitno0, widenSto64(getIRegG(sz, pfx, modrm)) );
8005 assign( t_rsp, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(288)) );
8011 assign( t_addr0, mkexpr(t_rsp) );
8015 assign( t_bitno1, binop(Iop_And64,
8022 assign( t_bitno1, mkexpr(t_bitno0) );
8031 assign( t_addr1,
8038 assign( t_bitno2,
8046 assign( t_mask, binop(Iop_Shl8, mkU8(1), mkexpr(t_bitno2)) );
8051 assign( t_fetched, loadLE(Ity_I8, mkexpr(t_addr1)) );
8056 assign( t_new,
8060 assign( t_new,
8064 assign( t_new,
8138 assign( src, getIRegE(sz, pfx, modrm) );
8143 assign( src, loadLE(ty, mkexpr(addr)) );
8152 assign( src64, widenUto64(mkexpr(src)) );
8160 assign( srcB, binop(Iop_ExpCmpNE64, mkexpr(src64), mkU64(0)) );
8206 assign( dst64,
8220 assign( dst, unop(Iop_64to16, mkexpr(dst64)) );
8223 assign( dst, unop(Iop_64to32, mkexpr(dst64)) );
8225 assign( dst, mkexpr(dst64) );
8244 assign( t1, getIReg64(R_RAX) );
8245 assign( t2, getIRegRexB(8, pfx, regLo3) );
8249 assign( t1, getIReg32(R_RAX) );
8250 assign( t2, getIRegRexB(4, pfx, regLo3) );
8254 assign( t1, getIReg16(R_RAX) );
8255 assign( t2, getIRegRexB(2, pfx, regLo3) );
8277 assign( oldflags, mk_amd64g_calculate_rflags_all() );
8303 assign( flags, mk_amd64g_calculate_rflags_all() );
8367 assign( dest, getIRegE(size, pfx, rm) );
8369 assign( src, getIRegG(size, pfx, rm) );
8370 assign( acc, getIRegRAX(size) );
8372 assign( cond, mk_amd64g_calculate_condition(AMD64CondZ) );
8373 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
8374 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8384 assign( dest, loadLE(ty, mkexpr(addr)) );
8386 assign( src, getIRegG(size, pfx, rm) );
8387 assign( acc, getIRegRAX(size) );
8389 assign( cond, mk_amd64g_calculate_condition(AMD64CondZ) );
8390 assign( dest2, IRExpr_ITE(mkexpr(cond), mkexpr(src), mkexpr(dest)) );
8391 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8405 assign( src, getIRegG(size, pfx, rm) );
8406 assign( acc, getIRegRAX(size) );
8412 assign( cond, mk_amd64g_calculate_condition(AMD64CondZ) );
8413 assign( acc2, IRExpr_ITE(mkexpr(cond), mkexpr(acc), mkexpr(dest)) );
8458 assign( tmps, getIRegE(sz, pfx, rm) );
8459 assign( tmpd, getIRegG(sz, pfx, rm) );
8475 assign( tmps, loadLE(ty, mkexpr(addr)) );
8476 assign( tmpd, getIRegG(sz, pfx, rm) );
8519 assign( tmpd, getIRegE(sz, pfx, rm) );
8520 assign( tmpt0, getIRegG(sz, pfx, rm) );
8521 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
8534 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8535 assign( tmpt0, getIRegG(sz, pfx, rm) );
8536 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
8549 assign( tmpd, loadLE(ty, mkexpr(addr)) );
8550 assign( tmpt0, getIRegG(sz, pfx, rm) );
8551 assign( tmpt1, binop(mkSizedOp(ty,Iop_Add8),
8627 //.. assign( t1, getSReg(sreg) );
8628 //.. assign( ta, binop(Iop_Sub32, getIReg(4, R_ESP), mkU32(sz)) );
8642 //.. assign( ta, getIReg(4, R_ESP) );
8643 //.. assign( t1, loadLE(Ity_I16, mkexpr(ta)) );
8656 assign(t1, getIReg64(R_RSP));
8657 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
8658 assign(t3, binop(Iop_Add64, mkexpr(t1), mkU64(8+d64)));
8793 assign( epart, unop( Iop_32UtoV128,
8829 assign( epart, unop( Iop_64UtoV128,
8889 assign( oldG0, getXMMReg(gregOfRexRM(pfx,rm)) );
8892 assign( oldG1,
8903 assign( oldG1,
8933 assign( oldG0, getXMMReg(gregOfRexRM(pfx,rm)) );
8936 assign( oldG1,
8947 assign( oldG1,
9142 assign( plain, binop(op, getXMMReg(gregOfRexRM(pfx,rm)),
9156 assign( plain,
9210 assign( amt, getXMMRegLane64(eregOfRexRM(pfx,rm), 0) );
9217 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
9223 assign( g0, getXMMReg(gregOfRexRM(pfx,rm)) );
9224 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
9241 assign(
9251 assign(
9287 assign( e0, getXMMReg(eregOfRexRM(pfx,rm)) );
9304 assign( e1, amt >= size
9310 assign( e1, amt >= size
9350 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
9351 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
9362 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
9363 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
9364 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
9365 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
9389 assign( hi32, unop(Iop_64HIto32, mkexpr(t64)) );
9390 assign( lo32, unop(Iop_64to32, mkexpr(t64)) );
9401 assign( *t0, unop(Iop_32to16, mkexpr(lo32)) );
9402 assign( *t1, unop(Iop_32HIto16, mkexpr(lo32)) );
9403 assign( *t2, unop(Iop_32to16, mkexpr(hi32)) );
9404 assign( *t3, unop(Iop_32HIto16, mkexpr(hi32)) );
9434 assign( *t0, unop(Iop_V256to64_0, mkexpr(t256)) );
9435 assign( *t1, unop(Iop_V256to64_1, mkexpr(t256)) );
9436 assign( *t2, unop(Iop_V256to64_2, mkexpr(t256)) );
9437 assign( *t3, unop(Iop_V256to64_3, mkexpr(t256)) );
9450 assign(*t1, unop(Iop_V256toV128_1, mkexpr(t256)));
9451 assign(*t0, unop(Iop_V256toV128_0, mkexpr(t256)));
9480 assign( *t0, unop(Iop_V128to64, mkexpr(t128)) );
9481 assign( *t1, unop(Iop_V128HIto64, mkexpr(t128)) );
9530 assign(aa, aax);
9531 assign(bb, bbx);
9532 assign( aahi32s,
9536 assign( aalo32s,
9540 assign( bbhi32s,
9544 assign( bblo32s,
9548 assign(one32x2, mkU64( (1ULL << 32) + 1 ));
9549 assign(
9565 assign(
9610 assign( aa, aax );
9611 assign( bb, bbx );
9612 assign( zero, mkU64(0) );
9613 assign( bbNeg, binop(opSub, mkexpr(zero), mkexpr(bb)) );
9614 assign( negMask, binop(opCmpGTS, mkexpr(zero), mkexpr(aa)) );
9615 assign( posMask, binop(opCmpGTS, mkexpr(aa), mkexpr(zero)) );
9651 assign( negMask, binop(opSarN, mkexpr(aa), mkU8(8*laneszB-1)) );
9652 assign( posMask, unop(Iop_Not64, mkexpr(negMask)) );
9653 assign( zero, mkU64(0) );
9654 assign( aaNeg, binop(opSub, mkexpr(zero), mkexpr(aa)) );
9655 assign( res,
9668 assign(aaHi, unop(Iop_V128HIto64, mkexpr(aa)));
9669 assign(aaLo, unop(Iop_V128to64, mkexpr(aa)));
9670 assign(res, binop(Iop_64HLtoV128,
9697 assign(res, binop(Iop_V128HLtoV256,
9736 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
9737 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
9738 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
9739 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
9742 assign( rHi, mkexpr(sHi) );
9743 assign( rLo, mkexpr(sLo) );
9746 assign( rHi, dis_PALIGNR_XMM_helper(dLo, sHi, imm8) );
9747 assign( rLo, dis_PALIGNR_XMM_helper(sHi, sLo, imm8) );
9750 assign( rHi, mkexpr(dLo) );
9751 assign( rLo, mkexpr(sHi) );
9754 assign( rHi, dis_PALIGNR_XMM_helper(dHi, dLo, imm8-8) );
9755 assign( rLo, dis_PALIGNR_XMM_helper(dLo, sHi, imm8-8) );
9758 assign( rHi, mkexpr(dHi) );
9759 assign( rLo, mkexpr(dLo) );
9762 assign( rHi, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-16))) );
9763 assign( rLo, dis_PALIGNR_XMM_helper(dHi, dLo, imm8-16) );
9766 assign( rHi, mkU64(0) );
9767 assign( rLo, mkexpr(dHi) );
9770 assign( rHi, mkU64(0) );
9771 assign( rLo, binop(Iop_Shr64, mkexpr(dHi), mkU8(8*(imm8-24))) );
9774 assign( rHi, mkU64(0) );
9775 assign( rLo, mkU64(0) );
9780 assign( res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
9959 assign( argR, getXMMRegLane64F( eregOfRexRM(pfx,modrm),
9968 assign( argR, loadLE(Ity_F64, mkexpr(addr)) );
9975 assign( argL, getXMMRegLane64F( gregOfRexRM(pfx,modrm),
10002 assign( argR, getXMMRegLane32F( eregOfRexRM(pfx,modrm),
10011 assign( argR, loadLE(Ity_F32, mkexpr(addr)) );
10018 assign( argL, getXMMRegLane32F( gregOfRexRM(pfx,modrm),
10047 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
10056 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
10070 assign(dV,
10093 assign( sV, getYMMReg(rE) );
10100 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
10133 assign(dV, mkV128(0x0000));
10137 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
10138 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
10141 assign( lo64r, mkexpr(lo64) );
10142 assign( hi64r, mkexpr(hi64) );
10146 assign( hi64r, mkU64(0) );
10147 assign( lo64r, mkexpr(hi64) );
10151 assign( hi64r, mkU64(0) );
10152 assign( lo64r, binop( Iop_Shr64, mkexpr(hi64), mkU8( 8*(imm-8) ) ));
10154 assign( hi64r, binop( Iop_Shr64, mkexpr(hi64), mkU8(8 * imm) ));
10155 assign( lo64r,
10165 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
10180 assign(dV, mkV128(0x0000));
10184 assign( hi64, unop(Iop_V128HIto64, mkexpr(sV)) );
10185 assign( lo64, unop(Iop_V128to64, mkexpr(sV)) );
10188 assign( lo64r, mkexpr(lo64) );
10189 assign( hi64r, mkexpr(hi64) );
10193 assign( lo64r, mkU64(0) );
10194 assign( hi64r, mkexpr(lo64) );
10198 assign( lo64r, mkU64(0) );
10199 assign( hi64r, binop( Iop_Shl64, mkexpr(lo64), mkU8( 8*(imm-8) ) ));
10201 assign( lo64r, binop( Iop_Shl64, mkexpr(lo64), mkU8(8 * imm) ));
10202 assign( hi64r,
10212 assign( dV, binop(Iop_64HLtoV128, mkexpr(hi64r), mkexpr(lo64r)) );
10231 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
10238 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
10247 assign( rmode, mkU32((UInt)Irrm_ZERO) );
10249 assign( rmode, get_sse_roundingmode() );
10279 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
10286 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
10295 assign( rmode, mkU32((UInt)Irrm_ZERO) );
10297 assign( rmode, get_sse_roundingmode() );
10329 assign( f32lo, getXMMRegLane32F(rE, 0) );
10330 assign( f32hi, getXMMRegLane32F(rE, 1) );
10336 assign( f32lo, loadLE(Ity_F32, mkexpr(addr)) );
10337 assign( f32hi, loadLE(Ity_F32,
10366 assign( f32_0, getXMMRegLane32F(rE, 0) );
10367 assign( f32_1, getXMMRegLane32F(rE, 1) );
10368 assign( f32_2, getXMMRegLane32F(rE, 2) );
10369 assign( f32_3, getXMMRegLane32F(rE, 3) );
10374 assign( f32_0, loadLE(Ity_F32, mkexpr(addr)) );
10375 assign( f32_1, loadLE(Ity_F32,
10377 assign( f32_2, loadLE(Ity_F32,
10379 assign( f32_3, loadLE(Ity_F32,
10405 assign( argV, getXMMReg(rE) );
10411 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10417 assign( rmode, get_sse_roundingmode() );
10420 assign( t0, unop(Iop_ReinterpI64asF64,
10422 assign( t1, unop(Iop_ReinterpI64asF64,
10452 assign( argV, getXMMReg(rE) );
10458 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10464 assign( rmode, r2zero ? mkU32((UInt)Irrm_ZERO)
10502 assign( argV, getYMMReg(rE) );
10508 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10514 assign( rmode, r2zero ? mkU32((UInt)Irrm_ZERO)
10554 assign( argV, getXMMReg(rE) );
10560 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10567 assign(rmode, mkU32((UInt)Irrm_ZERO) );
10569 assign( rmode, get_sse_roundingmode() );
10574 assign( t0, unop(Iop_ReinterpI64asF64,
10576 assign( t1, unop(Iop_ReinterpI64asF64,
10609 assign( argV, getYMMReg(rE) );
10615 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10622 assign(rmode, mkU32((UInt)Irrm_ZERO) );
10624 assign( rmode, get_sse_roundingmode() );
10663 assign( argV, getXMMReg(rE) );
10669 assign( argV, loadLE(Ity_V128, mkexpr(addr)) );
10675 assign( rmode, get_sse_roundingmode() );
10711 assign( argV, getYMMReg(rE) );
10716 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
10721 assign( rmode, get_sse_roundingmode() );
10759 assign(t0, getXMMReg(rE));
10760 assign(t1, unop(Iop_16Uto32, unop(Iop_GetMSBs8x16, mkexpr(t0))));
10780 assign(t0, getYMMRegLane128(rE, 0));
10781 assign(t1, getYMMRegLane128(rE, 1));
10782 assign(t2, unop(Iop_GetMSBs8x16, mkexpr(t0)));
10783 assign(t3, unop(Iop_GetMSBs8x16, mkexpr(t1)));
10801 assign(res, xIsH ? mkV128from32s( s3, d3, s2, d2 )
10815 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10816 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10817 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10818 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10820 assign(res, xIsH ? binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1))
10837 assign(res, xIsH
10861 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10878 assign(res,
10899 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10911 assign( d1, unop(Iop_V128HIto64, mkexpr(dV)) );
10912 assign( d0, unop(Iop_V128to64, mkexpr(dV)) );
10913 assign( s1, unop(Iop_V128HIto64, mkexpr(sV)) );
10914 assign( s0, unop(Iop_V128to64, mkexpr(sV)) );
10920 assign(res, binop( Iop_64HLtoV128,
10938 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10955 assign( imm8_mask, mkV128( imm8_mask_16 ) );
10958 assign ( res, binop( Iop_OrV128,
10976 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
10988 assign( imm8_mask, mkV128( imm8_perms[ (imm8 & 15) ] ) );
10991 assign ( res, binop( Iop_OrV128,
11009 assign(rV, binop(Iop_V128HLtoV256, mkexpr(rVhi), mkexpr(rVlo)));
11025 assign( imm16_mask, mkV128( imm16 ));
11028 assign ( res, binop( Iop_OrV128,
11046 assign(res, binop(Iop_64HLtoV128,
11062 assign(res, binop(Iop_V128HLtoV256,
11078 assign(res, binop(Iop_64HLtoV128,
11094 assign(res, binop(Iop_V128HLtoV256,
11109 assign( resHi, mkIRExprCCall(Ity_I64, 0/*regparms*/,
11113 assign( resLo, mkIRExprCCall(Ity_I64, 0/*regparms*/,
11118 assign( res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo))) ;
11130 assign(res, binop(Iop_V128HLtoV256,
11145 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
11146 assign( addV, triop(Iop_Add64Fx2, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11147 assign( subV, triop(Iop_Sub64Fx2, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11149 assign( a1, unop(Iop_V128HIto64, mkexpr(addV) ));
11150 assign( s0, unop(Iop_V128to64, mkexpr(subV) ));
11153 assign( res, binop(Iop_64HLtoV128, mkexpr(a1), mkexpr(s0)) );
11166 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
11167 assign( addV, triop(Iop_Add64Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11168 assign( subV, triop(Iop_Sub64Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11174 assign( res, mkV256from64s( a3, s2, a1, s0 ) );
11187 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
11188 assign( addV, triop(Iop_Add32Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11189 assign( subV, triop(Iop_Sub32Fx4, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11195 assign( res, mkV128from32s( a3, s2, a1, s0 ) );
11210 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
11211 assign( addV, triop(Iop_Add32Fx8, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11212 assign( subV, triop(Iop_Sub32Fx8, mkexpr(rm), mkexpr(dV), mkexpr(sV)) );
11218 assign( res, mkV256from32s( a7, s6, a5, s4, a3, s2, a1, s0 ) );
11242 assign( sV, getXMMReg(rE) );
11250 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
11260 assign( sVmut, unop(xIsH ? Iop_V128HIto64 : Iop_V128to64, mkexpr(sV)) );
11261 assign( sVcon, unop(xIsH ? Iop_V128to64 : Iop_V128HIto64, mkexpr(sV)) );
11266 assign(dVmut, mk64from16s( SEL((imm8>>6)&3), SEL((imm8>>4)&3),
11270 assign(dV, xIsH ? binop(Iop_64HLtoV128, mkexpr(dVmut), mkexpr(sVcon))
11296 assign( sV, getYMMReg(rE) );
11303 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
11314 assign( dVhi, mk64from16s( s[4 + ((imm8>>6)&3)], s[4 + ((imm8>>4)&3)],
11316 assign( dVlo, mk64from16s( s[0 + ((imm8>>6)&3)], s[0 + ((imm8>>4)&3)],
11338 assign(sV, getXMMReg(rE));
11350 case 0: assign(d16, unop(Iop_32to16, mkexpr(s0))); break;
11351 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(s0))); break;
11352 case 2: assign(d16, unop(Iop_32to16, mkexpr(s1))); break;
11353 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(s1))); break;
11354 case 4: assign(d16, unop(Iop_32to16, mkexpr(s2))); break;
11355 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(s2))); break;
11356 case 6: assign(d16, unop(Iop_32to16, mkexpr(s3))); break;
11357 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(s3))); break;
11377 assign( arg64, getXMMRegLane64(rE, 0) );
11382 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
11457 assign( t64, mkIRExprCCall(
11470 assign( ew, unop(Iop_64HIto32, mkexpr(t64) ) );
11495 assign(halfshift, binop(Iop_Shl64,
11499 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
11501 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
11506 assign( res, binop(Iop_OrV128,
11522 assign( res,
11543 assign(res, binop(Iop_V128HLtoV256,
11562 assign( addr, handleAddrOverrides( vbi, pfx, getIReg64(R_RDI) ));
11563 assign( regD, getXMMReg( rG ));
11568 assign( mask,
11576 assign( olddata, loadLE( Ity_V128, mkexpr(addr) ));
11577 assign( newdata, binop(Iop_OrV128,
11604 assign( t0, binop( Iop_And32,
11607 assign( t1, binop( Iop_And32,
11610 assign( t2, binop( Iop_And32,
11613 assign( t3, binop( Iop_And32,
11639 assign( t0, binop( Iop_And32,
11642 assign( t1, binop( Iop_And32,
11645 assign( t2, binop( Iop_And32,
11648 assign( t3, binop( Iop_And32,
11651 assign( t4, binop( Iop_And32,
11654 assign( t5, binop( Iop_And32,
11657 assign( t6, binop( Iop_And32,
11660 assign( t7, binop( Iop_And32,
11684 assign( t0, binop( Iop_And32,
11687 assign( t1, binop( Iop_And32,
11707 assign( t0, binop( Iop_And32,
11710 assign( t1, binop( Iop_And32,
11713 assign( t2, binop( Iop_And32,
11716 assign( t3, binop( Iop_And32,
12006 assign( dV, getXMMReg(rG) );
12009 assign( sV, getXMMReg(rE) );
12015 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12034 assign( dV, getXMMReg(rG) );
12037 assign( sV, getXMMReg(rE) );
12043 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
12260 assign( arg64, getMMXReg(eregLO3ofRM(modrm)) );
12266 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12272 assign( rmode, get_sse_roundingmode() );
12295 assign( rmode, get_sse_roundingmode() );
12300 assign( arg32, getIReg32(eregOfRexRM(pfx,modrm)) );
12306 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
12320 assign( arg64, getIReg64(eregOfRexRM(pfx,modrm)) );
12326 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12348 assign( arg32, getIReg32(eregOfRexRM(pfx,modrm)) );
12354 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
12366 assign( arg64, getIReg64(eregOfRexRM(pfx,modrm)) );
12372 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12402 assign( arg64, getMMXReg(eregLO3ofRM(modrm)) );
12408 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
12466 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
12467 assign(f32hi, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 1));
12473 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
12474 assign(f32hi, loadLE(Ity_F32, binop( Iop_Add64,
12484 assign(rmode, mkU32((UInt)Irrm_ZERO) );
12486 assign( rmode, get_sse_roundingmode() );
12489 assign(
12552 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
12553 assign(f64hi, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 1));
12559 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
12560 assign(f64hi, loadLE(Ity_F64, binop( Iop_Add64,
12570 assign(rmode, mkU32((UInt)Irrm_ZERO) );
12572 assign( rmode, get_sse_roundingmode() );
12575 assign(
12819 assign(f32lo, getXMMRegLane32F(eregOfRexRM(pfx,modrm), 0));
12824 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)));
12844 assign(f64lo, getXMMRegLane64F(eregOfRexRM(pfx,modrm), 0));
12849 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)));
12855 assign( rmode, get_sse_roundingmode() );
13225 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
13234 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
13244 assign(dV,
13327 assign( sV, getXMMReg(reg) );
13342 assign( sV, getXMMReg(reg) );
13775 assign(t5, getMMXReg(gregLO3ofRM(modrm)));
13779 assign(t4, getIReg16(eregOfRexRM(pfx,modrm)));
13789 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
13796 case 0: assign(t6, mk64from16s(t3,t2,t1,t4)); break;
13797 case 1: assign(t6, mk64from16s(t3,t2,t4,t0)); break;
13798 case 2: assign(t6, mk64from16s(t3,t4,t1,t0)); break;
13799 case 3: assign(t6, mk64from16s(t4,t2,t1,t0)); break;
13815 assign(t4, getIReg16(rE));
13825 assign(t4, loadLE(Ity_I16, mkexpr(addr)));
13830 assign(src_vec, getXMMReg(rG));
13847 assign(sV, getMMXReg(eregLO3ofRM(modrm)));
13850 case 0: assign(t5, mkexpr(t0)); break;
13851 case 1: assign(t5, mkexpr(t1)); break;
13852 case 2: assign(t5, mkexpr(t2)); break;
13853 case 3: assign(t5, mkexpr(t3)); break;
13894 assign( dV, getXMMReg(rG) );
13897 assign( sV, getXMMReg(rE) );
13903 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
13919 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
13922 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
13930 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14065 assign(t0, getMMXReg(eregLO3ofRM(modrm)));
14066 assign(t1, unop(Iop_8Uto32, unop(Iop_GetMSBs8x8, mkexpr(t0))));
14414 assign( dV, getXMMReg(rG) );
14417 assign( sV, getXMMReg(rE) );
14422 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14440 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
14443 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
14449 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
14455 assign( t0, unop(Iop_64to32, mkexpr(dV)) );
14456 assign( t1, unop(Iop_64to32, mkexpr(sV)) );
14473 assign( sV, getXMMReg(rE) );
14478 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14482 assign( dV, getXMMReg(rG) );
14506 assign( sV, getXMMReg(rE) );
14511 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14515 assign( dV, getXMMReg(rG) );
14641 assign( sV, getXMMReg(rE) );
14645 assign ( d0, unop(Iop_V128to64, mkexpr(sV)) );
14648 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
14673 assign ( d0, getYMMRegLane64(rE, 0) );
14674 assign ( d1, getYMMRegLane64(rE, 2) );
14677 assign( d0, loadLE(Ity_I64, mkexpr(addr)) );
14678 assign( d1, loadLE(Ity_I64, binop(Iop_Add64,
14704 assign( sV, getXMMReg(rE) );
14712 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
14738 assign( sV, getYMMReg(rE) );
14744 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
14769 assign( leftV, mkV128from32s( s2, s0, d2, d0 ) );
14770 assign( rightV, mkV128from32s( s3, s1, d3, d1 ) );
14773 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
14774 assign( res, triop(isAdd ? Iop_Add32Fx4 : Iop_Sub32Fx4,
14791 assign( leftV, binop(Iop_64HLtoV128, mkexpr(s0), mkexpr(d0)) );
14792 assign( rightV, binop(Iop_64HLtoV128, mkexpr(s1), mkexpr(d1)) );
14795 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
14796 assign( res, triop(isAdd ? Iop_Add64Fx2 : Iop_Sub64Fx2,
14860 assign( eV, getXMMReg(rE) );
14865 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14870 assign( gV, getXMMReg(rG) );
14885 assign( eV, getXMMReg(rE) );
14890 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14895 assign( gV, getXMMReg(rG) );
14910 assign( eV, getXMMReg(rE) );
14915 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14920 assign( gV, getXMMReg(rG) );
14934 assign( eV, getXMMReg(rE) );
14939 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
14944 assign( gV, getXMMReg(rG) );
15009 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15010 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15011 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15012 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15014 assign( sevens, mkU64(0x0707070707070707ULL) );
15023 assign(
15027 assign(
15033 assign(sAnd7hi, binop(Iop_And64,mkexpr(sHi),mkexpr(sevens)));
15035 assign(
15046 assign(rHi, binop(Iop_And64,mkexpr(permdHi),mkexpr(mask0x80hi)) );
15050 assign(
15054 assign(
15060 assign(sAnd7lo, binop(Iop_And64,mkexpr(sLo),mkexpr(sevens)));
15062 assign(
15073 assign(rLo, binop(Iop_And64,mkexpr(permdLo),mkexpr(mask0x80lo)) );
15075 assign(res, binop(Iop_64HLtoV128, mkexpr(rHi), mkexpr(rLo)));
15088 assign(res, binop(Iop_V128HLtoV256,
15129 assign( dV, getXMMReg(rV) );
15133 assign( sV, getXMMReg(rE) );
15141 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15147 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15148 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15149 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15150 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15200 assign( dV, getYMMReg(rV) );
15204 assign( sV, getYMMReg(rE) );
15209 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
15248 assign( sVoddsSX, binop(Iop_SarN16x8, mkexpr(sV), mkU8(8)) );
15249 assign( sVevensSX, binop(Iop_SarN16x8,
15252 assign( dVoddsZX, binop(Iop_ShrN16x8, mkexpr(dV), mkU8(8)) );
15253 assign( dVevensZX, binop(Iop_ShrN16x8,
15258 assign( res, binop(Iop_QAdd16Sx8,
15275 assign(res, binop(Iop_V128HLtoV256,
15308 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
15311 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
15318 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15335 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15338 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15344 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15429 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15432 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15438 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15465 assign( dV, getXMMReg(rG) );
15469 assign( sV, getXMMReg(rE) );
15475 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15495 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15498 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15504 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15511 assign( sVoddsSX,
15513 assign( sVevensSX,
15517 assign( dVoddsZX,
15519 assign( dVevensZX,
15560 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
15563 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
15570 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15576 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15577 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15578 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15579 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15608 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15611 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15617 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15644 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
15647 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
15654 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15660 assign( dHi, unop(Iop_V128HIto64, mkexpr(dV)) );
15661 assign( dLo, unop(Iop_V128to64, mkexpr(dV)) );
15662 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
15663 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
15682 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15685 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15691 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15726 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
15733 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15762 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15768 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15828 assign( dV, getXMMReg(gregOfRexRM(pfx,modrm)) );
15831 assign( sV, getXMMReg(eregOfRexRM(pfx,modrm)) );
15840 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
15860 assign( dV, getMMXReg(gregLO3ofRM(modrm)) );
15863 assign( sV, getMMXReg(eregLO3ofRM(modrm)) );
15871 assign( sV, loadLE(Ity_I64, mkexpr(addr)) );
15880 assign( res, mkexpr(sV) );
15883 assign(res,
15890 assign( res, mkexpr(dV) );
15893 assign( res, binop(Iop_Shr64, mkexpr(dV), mkU8(8*(d64-8))) );
15896 assign( res, mkU64(0) );
15957 assign(src, getIRegE(sz, pfx, modrm));
15963 assign(src, loadLE(ty, mkexpr(addr)));
16002 assign(src, getIRegE(sz, pfx, modrm));
16008 assign(src, loadLE(ty, mkexpr(addr)));
16023 assign(src64, widenUto64(mkexpr(src)));
16024 assign(res64, widenUto64(mkexpr(res)));
16027 assign(
16063 assign(src, getIRegE(sz, pfx, modrm));
16069 assign(src, loadLE(ty, mkexpr(addr)));
16084 assign(src64, widenUto64(mkexpr(src)));
16085 assign(res64, widenUto64(mkexpr(res)));
16088 assign(
16140 assign(sh, mkU8(8 * gran - 1));
16143 assign(mask, binop(opSAR, mkexpr(vec0), mkexpr(sh)));
16146 assign(notmask, unop(Iop_NotV128, mkexpr(mask)));
16149 assign(res, binop(Iop_OrV128,
16163 assign(sh, mkU8(8 * gran - 1));
16170 assign(mask, binop(Iop_V128HLtoV256,
16175 assign(notmask, unop(Iop_NotV256, mkexpr(mask)));
16178 assign(res, binop(Iop_OrV256,
16200 assign(vecE, getXMMReg(rE));
16209 assign(vecE, loadLE(Ity_V128, mkexpr(addr)));
16216 assign(vecV, getXMMReg(rV));
16217 assign(vecIS4, getXMMReg(rIS4));
16239 assign(vecE, getYMMReg(rE));
16248 assign(vecE, loadLE(Ity_V256, mkexpr(addr)));
16255 assign(vecV, getYMMReg(rV));
16256 assign(vecIS4, getYMMReg(rIS4));
16284 assign(and64,
16292 assign(andn64,
16305 assign(z64,
16309 assign(c64,
16319 assign(t0, mkU64(0x8000000080000000ULL));
16320 assign(t1, binop(Iop_And64, mkexpr(and64), mkexpr(t0)));
16321 assign(t2, binop(Iop_And64, mkexpr(andn64), mkexpr(t0)));
16330 assign(z64,
16337 assign(c64,
16348 assign(newOSZACP,
16375 assign(vecE, getXMMReg(rE));
16385 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
16393 assign(vecG, getXMMReg(rG));
16402 assign(andV, binop(Iop_AndV128, mkexpr(vecE), mkexpr(vecG)));
16403 assign(andnV, binop(Iop_AndV128,
16428 assign(vecE, getYMMReg(rE));
16435 assign(vecE, loadLE( Ity_V256, mkexpr(addr) ));
16442 assign(vecG, getYMMReg(rG));
16451 assign(andV, binop(Iop_AndV256, mkexpr(vecE), mkexpr(vecG)));
16452 assign(andnV, binop(Iop_AndV256,
16464 assign( andV128, binop( Iop_OrV128, mkexpr(andVhi), mkexpr(andVlo) ) );
16465 assign( andnV128, binop( Iop_OrV128, mkexpr(andnVhi), mkexpr(andnVlo) ) );
16486 assign( srcVec, getXMMReg(rE) );
16491 assign( srcVec,
16528 assign( srcVec, getXMMReg(rE) );
16533 assign( srcVec, loadLE( Ity_V128, mkexpr(addr) ) );
16570 assign( srcVec, getXMMReg(rE) );
16575 assign( srcVec,
16608 assign( srcVec, getXMMReg(rE) );
16613 assign( srcVec, loadLE( Ity_V128, mkexpr(addr) ) );
16647 assign( srcBytes, getXMMRegLane32( rE, 0 ) );
16652 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
16680 assign( srcBytes, getXMMRegLane64( rE, 0 ) );
16685 assign( srcBytes, loadLE( Ity_I64, mkexpr(addr) ) );
16715 assign( srcVec, getXMMReg(rE) );
16720 assign( srcVec,
16727 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
16750 assign( srcVec, getXMMReg(rE) );
16755 assign( srcVec,
16762 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
16796 assign( srcVec, getXMMReg(rE) );
16797 assign( srcI64, unop(Iop_V128to64, mkexpr(srcVec)) );
16802 assign( srcI64, loadLE(Ity_I64, mkexpr(addr)) );
16803 assign( srcVec, unop( Iop_64UtoV128, mkexpr(srcI64)) );
16841 assign( srcVec, getXMMReg(rE) );
16846 assign( srcVec, loadLE(Ity_V128, mkexpr(addr)) );
16891 assign( srcVec, getXMMReg(rE) );
16896 assign( srcVec,
16903 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
16933 assign( srcVec, getXMMReg(rE) );
16938 assign( srcVec,
16945 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
16980 assign( srcBytes, getXMMRegLane16( rE, 0 ) );
16985 assign( srcBytes, loadLE( Ity_I16, mkexpr(addr) ) );
17012 assign( srcBytes, getXMMRegLane32( rE, 0 ) );
17017 assign( srcBytes, loadLE( Ity_I32, mkexpr(addr) ) );
17059 assign( srcVec, getXMMReg(rE) );
17064 assign( srcVec,
17072 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
17097 assign( srcVec, getXMMReg(rE) );
17102 assign( srcVec,
17109 assign( zeroVec, IRExpr_Const( IRConst_V128(0) ) );
17145 assign( sV, getXMMReg(rE) );
17152 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
17156 assign( sHi, unop(Iop_V128HIto64, mkexpr(sV)) );
17157 assign( sLo, unop(Iop_V128to64, mkexpr(sV)) );
17158 assign( dLo, mkIRExprCCall(
17378 assign(vecE, getXMMReg(eregOfRexRM(pfx, modrm)));
17386 assign(vecE, loadLE( Ity_V128, mkexpr(addr) ));
17392 assign(vecG, getXMMReg(gregOfRexRM(pfx, modrm)));
17393 assign(vec0, getXMMReg(0));
17481 assign( dV, getXMMReg(rG) );
17484 assign( sV, getXMMReg(rE) );
17489 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
17540 assign( argL, getXMMReg( eregOfRexRM(pfx, modrm) ) );
17548 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
17554 assign(argR, getXMMReg( gregOfRexRM(pfx, modrm) ));
17723 assign( argL, getXMMReg( eregOfRexRM(pfx, modrm) ) );
17731 assign( argL, loadLE( Ity_V128, mkexpr(addr) ));
17737 assign(argR, getXMMReg( gregOfRexRM(pfx, modrm) ));
17791 assign(valE, getIRegE(sz, pfx, modrm));
17797 assign(valE, loadLE(tyE, mkexpr(addr)));
17808 assign(valG0, binop(Iop_And64, getIRegG(8, pfx, modrm),
17825 assign(valG1,
17874 assign( xmm_vec, getXMMReg(rG) );
17885 case 0: assign(d16, unop(Iop_32to16, mkexpr(t0))); break;
17886 case 1: assign(d16, unop(Iop_32HIto16, mkexpr(t0))); break;
17887 case 2: assign(d16, unop(Iop_32to16, mkexpr(t1))); break;
17888 case 3: assign(d16, unop(Iop_32HIto16, mkexpr(t1))); break;
17889 case 4: assign(d16, unop(Iop_32to16, mkexpr(t2))); break;
17890 case 5: assign(d16, unop(Iop_32HIto16, mkexpr(t2))); break;
17891 case 6: assign(d16, unop(Iop_32to16, mkexpr(t3))); break;
17892 case 7: assign(d16, unop(Iop_32HIto16, mkexpr(t3))); break;
17930 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
17941 case 0: assign( src_dword, mkexpr(t0) ); break;
17942 case 1: assign( src_dword, mkexpr(t1) ); break;
17943 case 2: assign( src_dword, mkexpr(t2) ); break;
17944 case 3: assign( src_dword, mkexpr(t3) ); break;
17979 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
17989 case 0: assign( src_qword, unop(Iop_V128to64, mkexpr(xmm_vec)) );
17991 case 1: assign( src_qword, unop(Iop_V128HIto64, mkexpr(xmm_vec)) );
18028 assign(argL, getXMMReg(regNoL));
18030 assign(argR, getXMMReg(regNoR));
18033 assign(zmaskL, unop(Iop_16Uto32,
18037 assign(zmaskR, unop(Iop_16Uto32,
18056 assign(zmaskL_zero, binop(Iop_ExpCmpNE32, mkexpr(zmaskL), mkU32(0)));
18059 assign(validL, binop(Iop_Sub32,
18068 assign(zmaskR_zero, binop(Iop_ExpCmpNE32, mkexpr(zmaskR), mkU32(0)));
18070 assign(validR, binop(Iop_Sub32,
18098 assign(intRes2, binop(Iop_And32, mkU32(0xFFFF),
18132 assign(cc, widenUto64(binop(Iop_Or32,
18292 assign(halfshift, binop(Iop_Shl64,
18296 assign(tmp128, binop(Iop_64HLtoV128, mkU64(0), mkexpr(halfshift)));
18298 assign(tmp128, binop(Iop_64HLtoV128, mkexpr(halfshift), mkU64(0)));
18303 assign( res, binop(Iop_OrV128,
18313 assign(z32, mkU32(0));
18321 assign(withZs, mkV128from32s(u32, z32, z32, z32));
18324 assign(withZs, mkV128from32s(z32, u32, z32, z32));
18327 assign(withZs, mkV128from32s(z32, z32, u32, z32));
18330 assign(withZs, mkV128from32s(z32, z32, z32, u32));
18336 assign(res, binop( Iop_OrV128,
18351 assign(withZs, binop(Iop_64HLtoV128, mkU64(0), mkexpr(u64)));
18355 assign( withZs, binop(Iop_64HLtoV128, mkexpr(u64), mkU64(0)));
18359 assign( res, binop( Iop_OrV128,
18377 assign( zero_32, mkU32(0) );
18379 assign( resV, mkV128from32s(
18401 assign( xmm_vec, getXMMReg( gregOfRexRM(pfx,modrm) ) );
18412 case 0: assign( sel_lane, mkexpr(t0) ); break;
18413 case 1: assign( sel_lane, mkexpr(t1) ); break;
18414 case 2: assign( sel_lane, mkexpr(t2) ); break;
18415 case 3: assign( sel_lane, mkexpr(t3) ); break;
18418 assign( shr_lane,
18447 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
18448 assign( and_vec, binop( Iop_AndV128,
18454 assign( sum_vec, binop( Iop_Add64F0x2,
18460 assign(res, binop( Iop_AndV128,
18482 assign( rm, get_FAKE_roundingmode() ); /* XXXROUNDINGFIXME */
18483 assign( tmp_prod_vec,
18489 assign( prod_vec, mkV128from32s( v3, v1, v2, v0 ) );
18491 assign( sum_vec, triop( Iop_Add32Fx4,
18499 assign( res, binop( Iop_AndV128,
18522 assign(src_maskV, mkV128( src_mask[ imm8 & 3 ] ));
18523 assign(dst_maskV, mkV128( dst_mask[ (imm8 >> 2) & 1 ] ));
18527 assign(src_masked, binop(Iop_AndV128, mkexpr(src_vec), mkexpr(src_maskV)));
18528 assign(dst_masked, binop(Iop_AndV128, mkexpr(dst_vec), mkexpr(dst_maskV)));
18533 assign( sHi, unop(Iop_V128HIto64, mkexpr(src_masked)) );
18534 assign( sLo, unop(Iop_V128to64, mkexpr(src_masked)) );
18538 assign( dHi, unop(Iop_V128HIto64, mkexpr(dst_masked)) );
18539 assign( dLo, unop(Iop_V128to64, mkexpr(dst_masked)) );
18552 assign(resHi, mkIRExprCCall( Ity_I64, 0/*regparm*/,
18555 assign(resLo, mkIRExprCCall( Ity_I64, 0/*regparm*/,
18560 assign(res, binop(Iop_64HLtoV128, mkexpr(resHi), mkexpr(resLo)));
18578 assign( xmm_vec, getXMMReg( rG ) );
18589 case 0: assign( src_dword, mkexpr(t0) ); break;
18590 case 1: assign( src_dword, mkexpr(t1) ); break;
18591 case 2: assign( src_dword, mkexpr(t2) ); break;
18592 case 3: assign( src_dword, mkexpr(t3) ); break;
18617 assign(t0, unop((imm8&1)? Iop_V128HIto64 : Iop_V128to64,
18619 assign(t1, unop((imm8&16) ? Iop_V128HIto64 : Iop_V128to64,
18628 assign(t2, mkIRExprCCall(Ity_I64,0, "amd64g_calculate_pclmul",
18631 assign(t3, mkIRExprCCall(Ity_I64,0, "amd64g_calculate_pclmul",
18635 assign(res, binop(Iop_64HLtoV128, mkexpr(t3), mkexpr(t2)));
18676 assign( src0,
18678 assign( src1,
18680 assign( src2,
18682 assign( src3,
18693 assign( src0, loadLE(Ity_F32,
18695 assign( src1, loadLE(Ity_F32,
18697 assign( src2, loadLE(Ity_F32,
18699 assign( src3, loadLE(Ity_F32,
18712 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
18714 assign(res0, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src0)) );
18715 assign(res1, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src1)) );
18716 assign(res2, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src2)) );
18717 assign(res3, binop(Iop_RoundF32toInt, mkexpr(rm), mkexpr(src3)) );
18742 assign( src0,
18744 assign( src1,
18755 assign( src0, loadLE(Ity_F64,
18757 assign( src1, loadLE(Ity_F64,
18770 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
18772 assign(res0, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src0)) );
18773 assign(res1, binop(Iop_RoundF64toInt, mkexpr(rm), mkexpr(src1)) );
18797 assign( src,
18809 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
18822 assign(res, binop(isD ? Iop_RoundF64toInt : Iop_RoundF32toInt,
18847 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
18851 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
18860 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
18883 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
18887 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
18896 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
18920 assign( dst_vec, getXMMReg( gregOfRexRM(pfx, modrm) ) );
18924 assign( src_vec, getXMMReg( eregOfRexRM(pfx, modrm) ) );
18933 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19010 assign( new8, unop(Iop_32to8, getIReg32(rE)) );
19017 assign( new8, loadLE( Ity_I8, mkexpr(addr) ) );
19023 assign(src_vec, getXMMReg( gregOfRexRM(pfx, modrm) ));
19044 assign( vE, getXMMReg(rE) );
19054 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
19062 assign( vG, getXMMReg(rG) );
19082 assign( src_u32, getIReg32( rE ) );
19089 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
19096 assign(src_vec, getXMMReg( rG ));
19113 assign( src_u64, getIReg64( rE ) );
19120 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
19127 assign(src_vec, getXMMReg( rG ));
19143 assign( dst_vec, getXMMReg( rG ) );
19147 assign( src_vec, getXMMReg(rE) );
19155 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19176 assign( dst_vec, getXMMReg( rG ) );
19180 assign( src_vec, getXMMReg(rE) );
19188 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19210 assign( dst_vec, getXMMReg(rG) );
19216 assign( src_vec, getXMMReg(rE) );
19224 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
19248 assign( dvec, getXMMReg(rG) );
19253 assign( svec, getXMMReg(rE) );
19261 assign( svec, loadLE( Ity_V128, mkexpr(addr) ) );
19620 assign(t1, getIRegRexB(sz, pfx, opc-0x50));
19621 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(sz)));
19641 assign(t2, getIReg64(R_RSP));
19642 assign(t1, loadLE(szToITy(sz),mkexpr(t2)));
19700 assign( t1, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
19865 assign(t1, getIRegE(sz, pfx, modrm));
19866 assign(t2, getIRegG(sz, pfx, modrm));
19876 assign( t1, loadLE(ty, mkexpr(addr)) );
19877 assign( t2, getIRegG(sz, pfx, modrm) );
19958 assign( t1, getIReg64(R_RSP) );
19959 assign( t3, loadLE(Ity_I64, mkexpr(t1)) );
20056 assign( t1, binop(Iop_Sub64,getIReg64(R_RSP),mkU64(sz)) );
20060 assign( t2, mk_amd64g_calculate_rflags_all() );
20065 assign( t3, binop(Iop_Or64,
20074 assign( t4, binop(Iop_Or64,
20084 assign( t5, binop(Iop_Or64,
20111 assign(t2, getIReg64(R_RSP));
20112 assign(t1, widenUto64(loadLE(szToITy(sz),mkexpr(t2))));
20189 assign( addr, handleAddrOverrides(vbi, pfx, mkU64(d64)) );
20207 assign( addr, handleAddrOverrides(vbi, pfx, mkU64(d64)) );
20486 assign(t1, getIReg64(R_RBP));
20488 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
20506 assign(t1, getIReg64(R_RBP));
20510 assign(t2, loadLE(Ity_I64,mkexpr(t1)));
20708 assign(t1, mkU64( abyte & 0xFF ));
20715 assign(t1, mkU64( abyte & 0xFF ));
20721 assign(t1, unop(Iop_16Uto64, getIRegRDX(2)));
20728 assign(t1, unop(Iop_16Uto64, getIRegRDX(2)));
20757 assign( t1, mkU64( abyte & 0xFF ) );
20764 assign( t1, mkU64( abyte & 0xFF ) );
20770 assign( t1, unop(Iop_16Uto64, getIRegRDX(2)) );
20777 assign( t1, unop(Iop_16Uto64, getIRegRDX(2)) );
20807 assign(t1, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
20811 assign(t2, mkU64((Addr64)d64));
20863 assign( t1, mk_amd64g_calculate_rflags_all() );
20866 assign( t2, binop(Iop_Xor64, mkexpr(t1),
20871 assign( t2, binop(Iop_And64, mkexpr(t1),
20876 assign( t2, binop(Iop_Or64, mkexpr(t1),
20964 assign( m8, mkU64(0xFF00FF00FF00FF00ULL) );
20965 assign( s8,
20976 assign( m16, mkU64(0xFFFF0000FFFF0000ULL) );
20977 assign( s16,
20988 assign( m32, mkU64(0xFFFFFFFF00000000ULL) );
20989 assign( t2,
21002 assign( t2,
21020 assign(t2,
21100 assign( t1, getIReg32(R_RCX) );
21340 assign( t1, unop(Iop_1Uto8,mk_amd64g_calculate_condition(opc-0x90)) );
21698 assign( expdHi64, getIReg64(R_RDX) );
21699 assign( expdLo64, getIReg64(R_RAX) );
21705 assign( expdHi, sz==4 ? unop(Iop_64to32, mkexpr(expdHi64))
21707 assign( expdLo, sz==4 ? unop(Iop_64to32, mkexpr(expdLo64))
21709 assign( dataHi, sz==4 ? getIReg32(R_RCX) : getIReg64(R_RCX) );
21710 assign( dataLo, sz==4 ? getIReg32(R_RBX) : getIReg64(R_RBX) );
21721 assign( success,
21761 assign( flags_old, widenUto64(mk_amd64g_calculate_rflags_all()));
21762 assign(
21800 assign( t1, getIRegRexB(4, pfx, opc-0xC8) );
21809 assign( t1, getIRegRexB(8, pfx, opc-0xC8) );
21999 assign(src, loadLE(ty, mkexpr(addr)));
22004 assign(src, getIRegG(sz, pfx, modrm));
22126 assign(tSL, invertLeftArg ? unop(Iop_NotV128, getXMMReg(rSL))
22132 assign(tSR, getXMMReg(rSR));
22138 assign(tSR, loadLE(Ity_V128, mkexpr(addr)));
22149 assign(rm, get_FAKE_roundingmode()); /* XXXROUNDINGFIXME */
22150 assign(res, swapArgs
22154 assign(res, swapArgs
22220 assign( amt, getXMMRegLane64(rE, 0) );
22226 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
22230 assign( g0, getXMMReg(rV) );
22231 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
22248 assign(
22258 assign(
22294 assign( amt, getXMMRegLane64(rE, 0) );
22300 assign( amt, loadLE(Ity_I64, mkexpr(addr)) );
22304 assign( g0, getYMMReg(rV) );
22305 assign( amt8, unop(Iop_64to8, mkexpr(amt)) );
22322 assign(
22332 assign(
22368 assign( amt, isYMM ? getYMMReg(rE) : getXMMReg(rE) );
22379 assign( amt, loadLE(isYMM ? Ity_V256 : Ity_V128, mkexpr(addr)) );
22389 assign( sV, isYMM ? getYMMReg(rV) : getXMMReg(rV) );
22431 assign( res[i],
22482 assign( e0, getXMMReg(eregOfRexRM(pfx,rm)) );
22499 assign( e1, amt >= size
22505 assign( e1, amt >= size
22539 assign( e0, getYMMReg(eregOfRexRM(pfx,rm)) );
22557 assign( e1, amt >= size
22563 assign( e1, amt >= size
22606 assign( epart, unop( Iop_64UtoV128,
22642 assign(e64, getXMMRegLane64(rE, 0));
22648 assign(e64, loadLE(Ity_I64, mkexpr(addr)));
22656 assign(arg,
22689 assign(e32, getXMMRegLane32(rE, 0));
22695 assign(e32, loadLE(Ity_I32, mkexpr(addr)));
22703 assign(arg,
22743 assign( epart, unop( Iop_32UtoV128,
22797 assign(argL, getXMMReg(rV));
22803 assign(argR, getXMMReg(rE));
22813 assign(argR,
22822 assign(plain, preSwap ? binop(op, mkexpr(argR), mkexpr(argL))
22857 assign(mask, mkV128(sz==4 ? 0x000F : 0x00FF));
22858 assign(notMask, mkV128(sz==4 ? 0xFFF0 : 0xFF00));
22860 assign(res,
22867 assign(res,
22911 assign(argL, getYMMReg(rV));
22918 assign(argR, getYMMReg(rE));
22929 assign(argR, loadLE(Ity_V256, mkexpr(addr)) );
22937 assign(plain, binop( Iop_V128HLtoV256,
22971 assign(arg, getXMMReg(rE));
22976 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
23002 assign(arg, getXMMReg(rE));
23007 assign(arg, loadLE(Ity_V128, mkexpr(addr)));
23039 assign(tSL, invertLeftArg ? unop(Iop_NotV256, getYMMReg(rSL))
23045 assign(tSR, getYMMReg(rSR));
23051 assign(tSR, loadLE(Ity_V256, mkexpr(addr)));
23062 assign(rm, get_FAKE_roundingmode()); /* XXXROUNDINGFIXME */
23063 assign(res, swapArgs
23067 assign(res, swapArgs
23146 assign(arg, getYMMReg(rE));
23151 assign(arg, loadLE(Ity_V256, mkexpr(addr)));
23177 assign(arg, getYMMReg(rE));
23182 assign(arg, loadLE(Ity_V256, mkexpr(addr)));
23205 assign( sV, getXMMReg(rE) );
23210 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
23242 assign( argV, getYMMReg(rE) );
23247 assign( argV, loadLE(Ity_V256, mkexpr(addr)) );
23252 assign( rmode, get_sse_roundingmode() );
23275 assign( res, binop( Iop_V128HLtoV256,
23386 assign(z128, mkV128(0));
23406 assign(res, binop(Iop_64HLtoV128,
23421 assign(z128, mkV128(0));
23441 assign( res, binop( Iop_64HLtoV128,
23544 assign(res, binop(Iop_64HLtoV128,
23574 assign( res, binop( Iop_64HLtoV128,
23676 assign(res, binop(Iop_64HLtoV128,
23697 assign(res, binop(Iop_64HLtoV128,
23745 assign( vV, getXMMReg(rV) );
23748 assign( eV, getXMMReg(rE) );
23754 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
23773 assign( vV, getYMMReg(rV) );
23776 assign( eV, getYMMReg(rE) );
23782 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
23801 assign( vV, getXMMReg(rV) );
23804 assign( eV, getXMMReg(rE) );
23810 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
23829 assign( vV, getYMMReg(rV) );
23832 assign( eV, getYMMReg(rE) );
23838 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
23863 assign(res, binop(Iop_64HLtoV128,
23884 assign(res, binop(Iop_64HLtoV128,
24076 assign( rmode, get_sse_roundingmode() );
24085 assign( arg32, getIReg32(rS) );
24091 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
24111 assign( arg64, getIReg64(rS) );
24117 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
24139 assign( arg64, getIReg64(rS) );
24145 assign( arg64, loadLE(Ity_I64, mkexpr(addr)) );
24169 assign( arg32, getIReg32(rS) );
24175 assign( arg32, loadLE(Ity_I32, mkexpr(addr)) );
24201 assign(tS, getXMMReg(rS));
24217 assign(tS, getYMMReg(rS));
24623 assign( rmode, get_sse_roundingmode() );
24626 assign(f64lo, getXMMRegLane64F(rS, 0));
24632 assign(f64lo, loadLE(Ity_F64, mkexpr(addr)) );
24654 assign(f32lo, getXMMRegLane32F(rS, 0));
24660 assign(f32lo, loadLE(Ity_F32, mkexpr(addr)) );
25204 assign(tD, getYMMReg(rS));
25211 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
25229 assign(tD, getXMMReg(rS));
25236 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
25403 assign( vecS, getXMMReg(rS) );
25412 assign( vecS, getXMMReg(rS) );
25445 assign( vecS0, getYMMRegLane128(rS, 0));
25446 assign( vecS1, getYMMRegLane128(rS, 1));
25458 assign( vecS0, getYMMRegLane128(rS, 0));
25459 assign( vecS1, getYMMRegLane128(rS, 1));
25537 assign(zero128, mkV128(0));
25548 assign(zero128, mkV128(0));
25571 assign( sV, getXMMReg(rE) );
25577 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
25582 assign( dV, getXMMReg(rV) );
25601 assign( sV, getYMMReg(rE) );
25607 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
25612 assign( dV, getYMMReg(rV) );
25633 assign( sV, getXMMReg(rE) );
25639 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
25644 assign( dV, getXMMReg(rV) );
25663 assign( sV, getYMMReg(rE) );
25669 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
25674 assign( dV, getYMMReg(rV) );
25763 assign(tS, getYMMReg(rS));
25788 assign(tS, getXMMReg(rS));
25899 assign( new16, unop(Iop_32to16,
25907 assign( new16, loadLE( Ity_I16, mkexpr(addr) ));
25914 assign(src_vec, getXMMReg( rV ));
25944 assign( vV, getXMMReg(rV) );
25947 assign( eV, getXMMReg(rE) );
25954 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
25974 assign( vV, getYMMReg(rV) );
25977 assign( eV, getYMMReg(rE) );
25984 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
26004 assign( vV, getXMMReg(rV) );
26007 assign( eV, getXMMReg(rE) );
26014 assign( eV, loadLE(Ity_V128, mkexpr(addr)) );
26034 assign( vV, getYMMReg(rV) );
26037 assign( eV, getYMMReg(rE) );
26044 assign( eV, loadLE(Ity_V256, mkexpr(addr)) );
26631 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
26644 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
26912 assign(res, binop(Iop_Perm32x4, mkexpr(dataV), cv1));
26925 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
26945 assign(res, binop(Iop_64HLtoV128, rHi, rLo));
26958 assign(res, binop(Iop_V128HLtoV256, mkexpr(rHi), mkexpr(rLo)));
26972 assign(res, binop(Iop_Perm32x8, mkexpr(dataV), cv1));
26988 assign( amt, getIRegV(size,pfx) );
26990 assign( src, getIRegE(size,pfx,rm) );
26996 assign( src, loadLE(ty, mkexpr(addr)) );
27086 assign( vX, ty == Ity_F64
27088 assign( vZ, ty == Ity_F64
27091 assign( vX, vty == Ity_V256 ? getYMMReg(rG) : getXMMReg(rG) );
27092 assign( vZ, vty == Ity_V256 ? getYMMReg(rV) : getXMMReg(rV) );
27099 assign( vY, ty == Ity_F64
27102 assign( vY, vty == Ity_V256 ? getYMMReg(rE) : getXMMReg(rE) );
27115 assign(vY, loadLE(vty, mkexpr(addr)));
27151 assign(tem, unop(ops[i / 2 + j], mkexpr(vX)));
27155 assign(tem, unop(ops[i / 2 + j], mkexpr(vY)));
27159 assign(tem, unop(ops[i / 2 + j], mkexpr(vZ)));
27222 assign( cond,
27227 assign( res[i],
27312 assign( cond,
27478 assign( dV, getXMMReg(rV) );
27482 assign( sV, getXMMReg(rE) );
27488 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
27529 assign( dV, getYMMReg(rV) );
27533 assign( sV, getYMMReg(rE) );
27539 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
27577 assign( dV, getXMMReg(rV) );
27581 assign( sV, getXMMReg(rE) );
27587 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
27616 assign( dV, getYMMReg(rV) );
27620 assign( sV, getYMMReg(rE) );
27626 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
27664 assign(ctrlV, getXMMReg(rE));
27670 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
27673 assign(dataV, getXMMReg(rV));
27691 assign(ctrlV, getYMMReg(rE));
27697 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
27700 assign(dataV, getYMMReg(rV));
27721 assign(ctrlV, getXMMReg(rE));
27727 assign(ctrlV, loadLE(Ity_V128, mkexpr(addr)));
27730 assign(dataV, getXMMReg(rV));
27748 assign(ctrlV, getYMMReg(rE));
27754 assign(ctrlV, loadLE(Ity_V256, mkexpr(addr)));
27757 assign(dataV, getYMMReg(rV));
27825 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
27827 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
27842 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
27844 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
27859 assign(t32, getXMMRegLane32(rE, 0));
27861 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
27876 assign(t32, getXMMRegLane32(rE, 0));
27878 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
27898 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
27913 assign(t64, getXMMRegLane64(rE, 0));
27933 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
28122 assign(tD, loadLE(Ity_V128, mkexpr(addr)));
28136 assign(tD, loadLE(Ity_V256, mkexpr(addr)));
28535 assign(t32, getXMMRegLane32(rE, 0));
28540 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
28543 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28558 assign(t32, getXMMRegLane32(rE, 0));
28563 assign(t32, loadLE(Ity_I32, mkexpr(addr)));
28566 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28585 assign(t64, getXMMRegLane64(rE, 0));
28590 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
28606 assign(t64, getXMMRegLane64(rE, 0));
28611 assign(t64, loadLE(Ity_I64, mkexpr(addr)));
28631 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
28647 assign(t8, unop(Iop_32to8, getXMMRegLane32(rE, 0)));
28652 assign(t8, loadLE(Ity_I8, mkexpr(addr)));
28655 assign(t16, binop(Iop_8HLto16, mkexpr(t8), mkexpr(t8)));
28657 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
28659 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28673 assign(t8, unop(Iop_32to8, getXMMRegLane32(rE, 0)));
28678 assign(t8, loadLE(Ity_I8, mkexpr(addr)));
28681 assign(t16, binop(Iop_8HLto16, mkexpr(t8), mkexpr(t8)));
28683 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
28685 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28703 assign(t16, unop(Iop_32to16, getXMMRegLane32(rE, 0)));
28708 assign(t16, loadLE(Ity_I16, mkexpr(addr)));
28711 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
28713 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
28727 assign(t16, unop(Iop_32to16, getXMMRegLane32(rE, 0)));
28732 assign(t16, loadLE(Ity_I16, mkexpr(addr)));
28735 assign(t32, binop(Iop_16HLto32, mkexpr(t16), mkexpr(t16)));
28737 assign(t64, binop(Iop_32HLto64, mkexpr(t32), mkexpr(t32)));
29066 assign( src1, getIRegV(size,pfx) );
29068 assign( src2, getIRegE(size,pfx,rm) );
29074 assign( src2, loadLE(ty, mkexpr(addr)) );
29080 assign( dst, binop( mkSizedOp(ty,Iop_And8),
29106 assign( src, getIRegE(size,pfx,rm) );
29112 assign( src, loadLE(ty, mkexpr(addr)) );
29117 assign( dst, binop(mkSizedOp(ty,Iop_And8),
29140 assign( src, getIRegE(size,pfx,rm) );
29146 assign( src, loadLE(ty, mkexpr(addr)) );
29151 assign( dst, binop(mkSizedOp(ty,Iop_Xor8),
29174 assign( src, getIRegE(size,pfx,rm) );
29180 assign( src, loadLE(ty, mkexpr(addr)) );
29185 assign( dst, binop(mkSizedOp(ty,Iop_And8),
29212 assign( src2, getIRegV(size,pfx) );
29214 assign( src1, getIRegE(size,pfx,rm) );
29220 assign( src1, loadLE(ty, mkexpr(addr)) );
29226 assign( start, narrowTo( Ity_I8, mkexpr(src2) ) );
29227 assign( cond, binop(Iop_CmpLT32U,
29238 assign( dst,
29275 assign( src, getIRegV(size,pfx) );
29277 assign( mask, getIRegE(size,pfx,rm) );
29283 assign( mask, loadLE(ty, mkexpr(addr)) );
29308 assign( src, getIRegV(size,pfx) );
29310 assign( mask, getIRegE(size,pfx,rm) );
29316 assign( mask, loadLE(ty, mkexpr(addr)) );
29349 assign( src1, getIRegRDX(size) );
29351 assign( src2, getIRegE(size,pfx,rm) );
29357 assign( src2, loadLE(ty, mkexpr(addr)) );
29363 assign( res, binop(size == 8 ? Iop_MullU64 : Iop_MullU32,
29408 assign( src2, getIRegV(size,pfx) );
29410 assign( src1, getIRegE(size,pfx,rm) );
29416 assign( src1, loadLE(ty, mkexpr(addr)) );
29422 assign( stle, narrowTo( Ity_I16, mkexpr(src2) ) );
29423 assign( start, unop( Iop_16to8, mkexpr(stle) ) );
29424 assign( len, unop( Iop_16HIto8, mkexpr(stle) ) );
29436 assign( dst,
29504 assign(res, mkV128from32s( SEL((imm8 >> 6) & 3),
29552 assign(sV, getYMMReg(rE));
29559 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
29566 assign(dV, IRExpr_Qop(Iop_64x4toV256,
29588 assign(sV, getXMMReg(rV));
29595 assign(dV, getXMMReg(rE));
29602 assign(dV, loadLE(Ity_V128, mkexpr(addr)));
29628 assign(sV, getYMMReg(rV));
29635 assign(dV, getYMMReg(rE));
29642 assign(dV, loadLE(Ity_V256, mkexpr(addr)));
29673 assign(sV, getYMMReg(rE));
29680 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
29703 assign(sV, getXMMReg(rE));
29710 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
29731 assign(sV, getXMMReg(rE));
29738 assign(sV, loadLE(Ity_V128, mkexpr(addr)));
29743 assign(s1, unop(Iop_V128HIto64, mkexpr(sV)));
29744 assign(s0, unop(Iop_V128to64, mkexpr(sV)));
29746 assign(dV, binop(Iop_64HLtoV128,
29764 assign(sV, getYMMReg(rE));
29771 assign(sV, loadLE(Ity_V256, mkexpr(addr)));
29778 assign(dV, IRExpr_Qop(Iop_64x4toV256,
29800 assign(s00, getYMMRegLane128(rV, 0));
29801 assign(s01, getYMMRegLane128(rV, 1));
29808 assign(s10, getYMMRegLane128(rE, 0));
29809 assign(s11, getYMMRegLane128(rE, 1));
29816 assign(s10, loadLE(Ity_V128, binop(Iop_Add64,
29818 assign(s11, loadLE(Ity_V128, binop(Iop_Add64,
29852 assign( src, getXMMReg( rE ) );
29859 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
29870 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
29904 assign( src, getYMMReg( rE ) );
29911 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
29922 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
29955 assign( src, getXMMReg( rE ) );
29962 assign( src, loadLE(Ity_V128, mkexpr(addr) ) );
29973 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
30001 assign( src, getYMMReg( rE ) );
30008 assign( src, loadLE(Ity_V256, mkexpr(addr) ) );
30019 assign(rm, (imm & 4) ? get_sse_roundingmode() : mkU32(imm & 3));
30049 assign( src,
30059 assign( src, loadLE( isD ? Ity_F64 : Ity_F32, mkexpr(addr) ));
30072 assign(res, binop(isD ? Iop_RoundF64toInt : Iop_RoundF32toInt,
30100 assign ( sV, getYMMReg(rV) );
30107 assign(sE, getYMMReg(rE));
30114 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30131 assign ( sV, getXMMReg(rV) );
30138 assign(sE, getXMMReg(rE));
30145 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30165 assign ( sV, getYMMReg(rV) );
30172 assign(sE, getYMMReg(rE));
30179 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30196 assign ( sV, getXMMReg(rV) );
30203 assign(sE, getXMMReg(rE));
30210 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30230 assign ( sV, getXMMReg(rV) );
30237 assign(sE, getXMMReg(rE));
30244 assign(sE, loadLE(Ity_V128, mkexpr(addr)));
30263 assign ( sV, getYMMReg(rV) );
30270 assign(sE, getYMMReg(rE));
30277 assign(sE, loadLE(Ity_V256, mkexpr(addr)));
30301 assign( dV, getXMMReg(rV) );
30305 assign( sV, getXMMReg(rE) );
30312 assign( sV, loadLE(Ity_V128, mkexpr(addr)) );
30336 assign( dV, getYMMReg(rV) );
30340 assign( sV, getYMMReg(rE) );
30347 assign( sV, loadLE(Ity_V256, mkexpr(addr)) );
30422 assign(t128, getXMMReg(rE));
30428 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
30457 assign(t128, getYMMRegLane128(rS, ib & 1));
30465 assign(t128, getYMMRegLane128(rS, ib & 1));
30489 assign( src_u8, unop(Iop_32to8, getIReg32( rE )) );
30496 assign( src_u8, loadLE( Ity_I8, mkexpr(addr) ) );
30503 assign(src_vec, getXMMReg( rV ));
30525 assign( vE, getXMMReg(rE) );
30535 assign( d2ins, loadLE( Ity_I32, mkexpr(addr) ) );
30543 assign( vV, getXMMReg(rV) );
30564 assign( src_u32, getIReg32( rE ) );
30571 assign( src_u32, loadLE( Ity_I32, mkexpr(addr) ) );
30578 assign(src_vec, getXMMReg( rV ));
30596 assign( src_u64, getIReg64( rE ) );
30603 assign( src_u64, loadLE( Ity_I64, mkexpr(addr) ) );
30610 assign(src_vec, getXMMReg( rV ));
30632 assign(t128, getXMMReg(rE));
30638 assign(t128, loadLE(Ity_V128, mkexpr(addr)));
30667 assign(t128, getYMMRegLane128(rS, ib & 1));
30675 assign(t128, getYMMRegLane128(rS, ib & 1));
30697 assign( dst_vec, getXMMReg( rE ) );
30704 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
30711 assign(src_vec, getXMMReg( rV ));
30727 assign( dst_vec, getYMMReg( rE ) );
30734 assign( dst_vec, loadLE( Ity_V256, mkexpr(addr) ) );
30741 assign(src_vec, getYMMReg( rV ));
30765 assign( dst_vec, getXMMReg( rE ) );
30772 assign( dst_vec, loadLE( Ity_V128, mkexpr(addr) ) );
30779 assign(src_vec, getXMMReg( rV ));
30798 assign( dst_vec, getXMMReg(rV) );
30804 assign( src_vec, getXMMReg(rE) );
30811 assign( src_vec, loadLE( Ity_V128, mkexpr(addr) ) );
30835 assign( dst_vec, getYMMReg(rV) );
30841 assign( src_vec, getYMMReg(rE) );
30848 assign( src_vec, loadLE( Ity_V256, mkexpr(addr) ) );
30880 assign( dV, getXMMReg(rV) );
30885 assign( sV, getXMMReg(rE) );
30892 assign( sV, loadLE( Ity_V128, mkexpr(addr) ) );
30917 assign(s00, getYMMRegLane128(rV, 0));
30918 assign(s01, getYMMRegLane128(rV, 1));
30925 assign(s10, getYMMRegLane128(rE, 0));
30926 assign(s11, getYMMRegLane128(rE, 1));
30933 assign(s10, loadLE(Ity_V128, binop(Iop_Add64,
30935 assign(s11, loadLE(Ity_V128, binop(Iop_Add64,
31053 assign( src, getIRegE(size,pfx,rm) );
31060 assign( src, loadLE(ty, mkexpr(addr)) );
31193 assign(t1, getIRegRAX(8));
31195 assign(t2, binop(Iop_Sub64, getIReg64(R_RSP), mkU64(8)));
31842 // assign(t[0], binop(Iop_Or64, mkexpr(src),
31844 // assign(t[1], binop(Iop_Or64, mkexpr(t[0]),
31846 // assign(t[2], binop(Iop_Or64, mkexpr(t[1]),
31848 // assign(t[3], binop(Iop_Or64, mkexpr(t[2]),
31850 // assign(t[4], binop(Iop_Or64, mkexpr(t[3]),
31852 // assign(t[5], binop(Iop_Or64, mkexpr(t[4]),
31854 // assign(t[6], unop(Iop_Not64, mkexpr(t[5])));
31858 // assign(t[0], binop(Iop_Or32, mkexpr(src),
31860 // assign(t[1], binop(Iop_Or32, mkexpr(t[0]),
31862 // assign(t[2], binop(Iop_Or32, mkexpr(t[1]),
31864 // assign(t[3], binop(Iop_Or32, mkexpr(t[2]),
31866 // assign(t[4], binop(Iop_Or32, mkexpr(t[3]),
31868 // assign(t[5], unop(Iop_Not32, mkexpr(t[4])));
31872 // assign(t[0], binop(Iop_Or16, mkexpr(src),
31874 // assign(t[1], binop(Iop_Or16, mkexpr(t[0]),
31876 // assign(t[2], binop(Iop_Or16, mkexpr(t[1]),
31878 // assign(t[3], binop(Iop_Or16, mkexpr(t[2]),
31880 // assign(t[4], unop(Iop_Not16, mkexpr(t[3])));