Lines Matching full:mkexpr
290 static IRExpr* mkexpr ( IRTemp tmp )
350 return mkexpr(src);
353 binop(Iop_Shl32, mkexpr(src), mkU8(32 - rot)),
354 binop(Iop_Shr32, mkexpr(src), mkU8(rot)));
550 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
584 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
680 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
724 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
791 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
851 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
881 IRExpr_Mux0X( unop(Iop_32to8, mkexpr(guardT)),
900 stmt( IRStmt_Put( OFFB_ITSTATE, mkexpr(t)) );
912 putMiscReg32( OFFB_QFLAG32, mkexpr(t), condT );
923 assign(nyu, binop(Iop_Or32, mkexpr(old), e) );
951 case 0: putMiscReg32(OFFB_GEFLAG0, mkexpr(masked), condT); break;
952 case 1: putMiscReg32(OFFB_GEFLAG1, mkexpr(masked), condT); break;
953 case 2: putMiscReg32(OFFB_GEFLAG2, mkexpr(masked), condT); break;
954 case 3: putMiscReg32(OFFB_GEFLAG3, mkexpr(masked), condT); break;
979 assign(ge10, binop(Iop_And32, mkexpr(t32), mkU32(0x00008000)));
980 assign(ge32, binop(Iop_And32, mkexpr(t32), mkU32(0x80000000)));
981 put_GEFLAG32( 0, 0, mkexpr(ge10), condT );
982 put_GEFLAG32( 1, 0, mkexpr(ge10), condT );
983 put_GEFLAG32( 2, 0, mkexpr(ge32), condT );
984 put_GEFLAG32( 3, 0, mkexpr(ge32), condT );
997 assign(ge0, binop(Iop_And32, mkexpr
998 assign(ge1, binop(Iop_And32, mkexpr(t32), mkU32(0x00008000)));
999 assign(ge2, binop(Iop_And32, mkexpr(t32), mkU32(0x00800000)));
1000 assign(ge3, binop(Iop_And32, mkexpr(t32), mkU32(0x80000000)));
1001 put_GEFLAG32( 0, 0, mkexpr(ge0), condT );
1002 put_GEFLAG32( 1, 0, mkexpr(ge1), condT );
1003 put_GEFLAG32( 2, 0, mkexpr(ge2), condT );
1004 put_GEFLAG32( 3, 0, mkexpr(ge3), condT );
1039 binop(Iop_Shl32, mkexpr(armEncd), mkU8(1)),
1042 binop(Iop_Shr32, mkexpr(armEncd), mkU8(1)),
1318 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t_dep1) ));
1319 stmt( IRStmt_Put( OFFB_CC_DEP2, mkexpr(t_dep2) ));
1320 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(t_ndep) ));
1324 assign( c8, unop(Iop_32to8, mkexpr(guardT)) );
1327 IRExpr_Mux0X( mkexpr(c8),
1332 IRExpr_Mux0X( mkexpr(c8),
1334 mkexpr(t_dep1) )));
1337 IRExpr_Mux0X( mkexpr(c8),
1339 mkexpr(t_dep2) )));
1342 IRExpr_Mux0X( mkexpr(c8),
1344 mkexpr(t_ndep) )));
1400 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1416 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1433 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1450 binop(Iop_CmpNE32, mkexpr(t), mkU32(0)),
1474 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
1505 mkexpr(res1),
1509 mkexpr(get_QFLAG32()),
1525 mkexpr(res2),
1546 assign(immT, binop(Iop_And32, mkexpr(apsrT), mkU32(0xF0000000)) );
1550 assign(qnewT, binop(Iop_And32, mkexpr(apsrT), mkU32(ARMG_CC_MASK_Q)));
1555 put_GEFLAG32(0, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<16)),
1557 put_GEFLAG32(1, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<17)),
1559 put_GEFLAG32(2, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<18)),
1561 put_GEFLAG32(3, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<19)),
1603 assign( node0, mkexpr(regT) );
1605 assign( node2, binop( Iop_CmpLT32S, mkexpr(node1), mkexpr(node0) ) );
1606 assign( node3, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node2)),
1607 mkexpr(node0),
1608 mkexpr(node1) ) );
1610 assign( node5, binop( Iop_CmpLT32S, mkexpr(node3), mkexpr(node4) ) );
1611 assign( node6, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node5)),
1612 mkexpr(node3),
1613 mkexpr(node4) ) );
1614 assign( *res, mkexpr(node6) );
1619 assign( *resQ, binop(Iop_Xor32, mkexpr(*res), mkexpr(regT)) );
1651 assign( node0, mkexpr(regT) );
1653 assign( node2, binop( Iop_CmpLT32S, mkexpr(node1), mkexpr(node0) ) );
1654 assign( node3, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node2)),
1655 mkexpr(node0), mkexpr(node1) ) );
1657 assign( node5, binop( Iop_CmpLT32S, mkexpr(node3), mkexpr(node4) ) );
1658 assign( node6, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node5)),
1659 mkexpr(node3), mkexpr(node4) ) );
1660 assign( *res, mkexpr(node6) );
1665 assign( *resQ, binop(Iop_Xor32, mkexpr(*res), mkexpr(regT)) );
1682 binop( Iop_Xor32, mkexpr(res), mkexpr(argL) ),
1683 binop( Iop_Xor32, mkexpr(res), mkexpr(argR) )),
1717 assign( *res, mkexpr(rMt) );
1724 binop(Iop_Shr32, mkexpr(rMt),
1729 binop(Iop_Shl32, mkexpr(rMt), mkU8(shift_amt)) );
1749 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1765 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
1768 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
1771 mkexpr(rMt),
1776 mkexpr(amtT)),
1782 mkexpr(oldC)
1795 mkexpr(rMt),
1797 binop(Iop_And32, mkexpr(rSt), mkU32(31)))),
1800 mkexpr(amtT),
1822 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1835 binop(Iop_Shr32, mkexpr(rMt),
1840 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)) );
1860 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1874 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
1877 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
1880 mkexpr(rMt),
1884 mkexpr(amtT),
1891 mkexpr(oldC)
1904 mkexpr(rMt),
1906 binop(Iop_And32, mkexpr(rSt), mkU32(31)))),
1909 mkexpr(amtT),
1931 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1934 assign( *res, binop(Iop_Sar32, mkexpr(rMt), mkU8(31)) );
1944 binop(Iop_Shr32, mkexpr(rMt),
1949 binop(Iop_Sar32, mkexpr(rMt), mkU8(shift_amt)) );
1969 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1983 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
1986 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
1988 mkexpr(rMt),
1992 mkexpr(rMt),
1996 mkexpr(amtT),
2003 mkexpr(oldC)
2012 mkexpr(rMt),
2018 binop(Iop_CmpLT32U, mkexpr(amtT), mkU32(32))),
2020 mkexpr(amtT)))));
2038 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
2040 assign( amt5T, binop(Iop_And32, mkexpr(rSt), mkU32(31)) );
2047 unop(Iop_32to8, mkexpr(amtT)),
2048 mkexpr(oldC),
2051 mkexpr(rMt),
2055 mkexpr(amtT),
2070 unop(Iop_32to8, mkexpr(amt5T)), mkexpr(rMt),
2073 mkexpr(rMt),
2074 unop(Iop_32to8, mkexpr(amt5T))
2077 mkexpr(rMt),
2079 binop(Iop_Sub32, mkU32(32), mkexpr(amt5T))
2146 binop(Iop_And32, mkexpr(rMt), mkU32(1)));
2151 binop(Iop_Shl32, mkexpr(oldcT), mkU8(31)),
2152 binop(Iop_Shr32, mkexpr(rMt), mkU8(1))) );
2162 binop(Iop_Shr32, mkexpr(rMt),
2168 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)),
2169 binop(Iop_Shl32, mkexpr(rMt),
2405 binop(Iop_Shl32, mkexpr(cflagT), mkU8(31)),
2406 binop(Iop_Shr32, mkexpr(rmT), mkU8(1)));
2413 binop(Iop_Shl32, mkexpr(rmT), mkU8(32-imm5)),
2414 binop(Iop_Shr32, mkexpr(rmT), mkU8(imm5)));
2506 binop(Iop_Shr32, mkexpr(irRes), mkU8(5)),
2508 binop(Iop_And32, mkexpr(irRes), mkU32(1))));
2516 binop(Iop_Xor32, mkexpr(ix), mkU32(1)),
2526 mkexpr(ix),
2527 binop(Iop_Shr32, mkexpr(ix), mkU8(1))),
2530 assign(nzcv, binop(Iop_Sub32, mkexpr(termL), mkexpr(termR)));
2687 binop(Iop_And32, mkexpr(x0), mkU32(c1)),
2690 binop(Iop_And32, mkexpr(x0), mkU32(~c1)),
2696 binop(Iop_And32, mkexpr(x1), mkU32(c2)),
2699 binop(Iop_And32, mkexpr(x1), mkU32(~c2)),
2705 binop(Iop_And32, mkexpr(x2), mkU32(c3)),
2708 binop(Iop_And32, mkexpr(x2), mkU32(~c3)),
2714 binop(Iop_And32, mkexpr(x3), mkU32(c4)),
2717 binop(Iop_And32, mkexpr(x3), mkU32(~c4)),
2723 binop(Iop_And32, mkexpr(x4), mkU32(c5)),
2726 binop(Iop_And32, mkexpr(x4), mkU32(~c5)),
2740 binop(Iop_Shl32, mkexpr(arg), mkU8(24)),
2742 binop(Iop_And32, binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2745 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2747 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(24)),
2762 binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2765 binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2891 assign(new_arg, binop(Iop_Sub8x8, mkexpr(old_arg), mkU64(imm)));
2892 assign(cur_mask, binop(cmp, mkU64(imm), mkexpr(old_arg)));
2893 assign(new_mask, binop(Iop_Or64, mkexpr(old_mask), mkexpr(cur_mask)));
2895 mkexpr(old_res),
2898 mkexpr(arg_l),
2900 mkexpr(old_arg),
2901 mkexpr(cur_mask))),
2902 mkexpr(cur_mask))));
2913 unop(Iop_Not64, mkexpr(old_mask))),
2914 mkexpr(old_res)));
2918 putDRegI64(dreg, mkexpr(old_res), condT);
2973 assign(res, unop(op, binop(op2, mkexpr(arg_m), mkU8(index))));
2975 putQReg(dreg, mkexpr(res), condT);
2977 putDRegI64(dreg, mkexpr(res), condT);
3079 binop(shOp, mkexpr(arg_m), mkU8(1)),
3080 binop(shOp, mkexpr(arg_n), mkU8(1))),
3083 binop(andOp, mkexpr(arg_m), imm_val),
3084 binop(andOp, mkexpr(arg_n), imm_val)),
3142 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3144 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3145 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3213 mkexpr(arg_n),
3218 mkexpr(arg_m),
3229 mkexpr(arg_n),
3232 mkexpr(arg_m),
3234 mkexpr(cc)));
3241 mkexpr(arg_n),
3244 mkexpr(arg_m),
3251 mkexpr(arg_n),
3254 mkexpr(arg_m),
3256 mkexpr(cc)));
3268 assign(res, binop(Iop_AndV128, mkexpr(arg_n),
3269 mkexpr(arg_m)));
3271 assign(res, binop(Iop_And64, mkexpr(arg_n),
3272 mkexpr(arg_m)));
3282 assign(res, binop(Iop_AndV128,mkexpr(arg_n),
3283 unop(Iop_NotV128, mkexpr(arg_m))));
3285 assign(res, binop(Iop_And64, mkexpr(arg_n),
3286 unop(Iop_Not64, mkexpr(arg_m))));
3297 assign(res, binop(Iop_OrV128, mkexpr(arg_n),
3298 mkexpr(arg_m)));
3300 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3301 mkexpr(arg_m)));
3308 assign(res, mkexpr(arg_m));
3316 assign(res, binop(Iop_OrV128,mkexpr(arg_n),
3317 unop(Iop_NotV128, mkexpr(arg_m))));
3319 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3320 unop(Iop_Not64, mkexpr(arg_m))));
3332 assign(res, binop(Iop_XorV128, mkexpr(arg_n),
3333 mkexpr(arg_m)));
3335 assign(res, binop(Iop_Xor64, mkexpr(arg_n),
3336 mkexpr(arg_m)));
3348 binop(Iop_AndV128, mkexpr(arg_n),
3349 mkexpr(reg_d)),
3351 mkexpr(arg_m),
3353 mkexpr(reg_d)) ) ) );
3359 binop(Iop_And64, mkexpr(arg_n),
3360 mkexpr(reg_d)),
3362 mkexpr(arg_m),
3363 unop(Iop_Not64, mkexpr(reg_d)))));
3376 binop(Iop_AndV128, mkexpr(arg_n),
3377 mkexpr(arg_m)),
3379 mkexpr(reg_d),
3380 unop(Iop_NotV128, mkexpr(arg_m)))));
3386 binop(Iop_And64, mkexpr(arg_n),
3387 mkexpr(arg_m)),
3389 mkexpr(reg_d),
3390 unop(Iop_Not64, mkexpr(arg_m)))));
3403 binop(Iop_AndV128, mkexpr(reg_d),
3404 mkexpr(arg_m)),
3406 mkexpr(arg_n),
3407 unop(Iop_NotV128, mkexpr(arg_m)))));
3413 binop(Iop_And64, mkexpr(reg_d),
3414 mkexpr(arg_m)),
3416 mkexpr(arg_n),
3417 unop(Iop_Not64, mkexpr(arg_m)))));
3492 binop(shOp, mkexpr(arg_n), mkU8(1)),
3493 binop(shOp, mkexpr(arg_m), mkU8(1))),
3496 unop(notOp, mkexpr(arg_n)),
3497 mkexpr(arg_m)),
3554 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3556 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3557 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3586 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3599 binop(op, mkexpr(arg_m), mkexpr(arg_n))));
3645 assign(res, binop(op, mkexpr(arg_m),
3646 unop(Iop_64to8, mkexpr(arg_n))));
3648 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3653 mkexpr(arg_n)));
3655 assign(tmp, binop(sub_op, mkU64(0), mkexpr(arg_n)));
3657 assign(res, binop(op, mkexpr(arg_m),
3658 unop(Iop_64to8, mkexpr(tmp))));
3660 assign(res, binop(op, mkexpr(arg_m), mkexpr(tmp)));
3742 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3748 mkexpr(arg_n),
3755 mkexpr(old_shval),
3757 mkexpr(old_shval),
3767 binop(cmp_gt, mkexpr(shval),
3769 unop(cmp_neq, mkexpr(arg_m))),
3775 assign(mask, binop(cmp_gt, mkexpr(shval),
3778 assign(tmp, binop(op_rev, mkexpr(res),
3779 unop(Iop_64to8, mkexpr(arg_n))));
3781 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
3783 mkexpr(tmp), mkexpr(mask)),
3785 mkexpr(arg_m), mkexpr(mask)),
3889 mkexpr(arg_n),
3896 mkexpr(old_shval),
3898 mkexpr(old_shval),
3905 mkexpr(arg_m),
3908 mkexpr(arg_n),
3909 mkexpr(imm_val)))),
3911 mkexpr(imm_val),
3914 mkexpr(arg_n)))));
3917 mkexpr(arg_m),
3918 unop(Iop_64to8, mkexpr(arg_n))),
3919 mkexpr(round)));
3923 mkexpr(arg_m),
3925 mkexpr(arg_n),
3926 mkexpr(imm_val))),
3928 mkexpr(imm_val),
3931 mkexpr(arg_n)))));
3933 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
3934 mkexpr(round)));
4047 mkexpr(arg_n),
4054 mkexpr(old_shval),
4056 mkexpr(old_shval),
4062 mkexpr(arg_m),
4064 mkexpr(arg_n),
4065 mkexpr(imm_val))),
4067 mkexpr(imm_val),
4070 mkexpr(arg_n)))));
4072 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4073 mkexpr(round)));
4082 binop(cmp_gt, mkexpr(shval),
4084 unop(cmp_neq, mkexpr(arg_m))),
4090 assign(mask, binop(cmp_gt, mkexpr(shval),
4093 assign(tmp, binop(op_rev, mkexpr(res),
4094 unop(Iop_64to8, mkexpr(arg_n))));
4096 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
4098 mkexpr(tmp), mkexpr(mask)),
4100 mkexpr(arg_m), mkexpr(mask)),
4131 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4156 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4215 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4218 binop(op_sub, mkexpr(arg_n),
4219 mkexpr(arg_m)),
4220 mkexpr(cond)),
4222 binop(op_sub, mkexpr(arg_m),
4223 mkexpr(arg_n)),
4225 mkexpr(cond)))));
4293 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4296 binop(op_sub, mkexpr(arg_n),
4297 mkexpr(arg_m)),
4298 mkexpr(cond)),
4300 binop(op_sub, mkexpr(arg_m),
4301 mkexpr(arg_n)),
4303 mkexpr(cond)))));
4304 assign(res, binop(op_add, mkexpr(acc), mkexpr(tmp)));
4339 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4352 mkexpr(arg_n),
4353 mkexpr(arg_m))));
4362 mkexpr(arg_n),
4363 mkexpr(arg_m)))));
4416 binop(op, mkexpr(arg_n), mkexpr(arg_m))));
4442 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4472 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4504 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4507 binop(op2, mkexpr(arg_n),
4509 binop(op2, mkexpr(arg_m),
4540 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4543 binop(op2, mkexpr(arg_n),
4545 binop(op2, mkexpr(arg_m),
4567 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4604 mkexpr(arg_n),
4605 mkexpr(arg_m))));
4609 mkexpr(arg_n),
4610 mkexpr(arg_m))));
4618 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4645 binop(op, mkexpr(arg_n), mkexpr(arg_m))));
4656 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4672 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4686 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4696 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4711 unop(op2, mkexpr(arg_n)),
4712 unop(op2, mkexpr(arg_m))));
4716 unop(op2, mkexpr(arg_n)),
4717 unop(op2, mkexpr(arg_m))));
4741 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4756 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4765 mkexpr(arg_n),
4766 mkexpr(arg_m)));
4774 mkexpr(arg_n),
4775 mkexpr(arg_m)));
4785 putQReg(dreg, mkexpr(res), condT);
4787 putDRegI64(dreg, mkexpr(res), condT);
4844 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
4891 assign(res, binop(op, mkexpr(tmp),
4894 assign(res, mkexpr(tmp));
4896 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
4947 binop(op, mkexpr(arg_n), mkexpr(arg_m)),
4948 mkexpr(cond)),
4950 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4951 unop(Iop_NotV128, mkexpr(cond)))),
4953 putQReg(dreg, mkexpr(res), condT);
5001 assign(res, binop(op2, mkexpr(tmp),
5004 assign(res, mkexpr(tmp));
5006 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
5053 binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5054 mkexpr(cond)),
5056 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
5057 unop(Iop_NotV128, mkexpr(cond)))));
5058 putQReg(dreg, mkexpr(res), condT);
5089 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5129 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5130 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5138 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5324 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5326 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)),
5329 putDRegI64(dreg, binop(op2, getDRegI64(dreg), mkexpr(res)),
5386 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5387 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5453 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5455 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5457 binop(cmp, mkexpr(arg_n), mkU64(imm)),
5458 binop(cmp, mkexpr(arg_m), mkU64(imm))),
5461 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5464 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5542 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5544 putQReg(dreg, mkexpr(res), condT);
5546 putDRegI64(dreg, mkexpr(res), condT);
5589 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5590 putQReg(dreg, mkexpr(res), condT);
5648 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5652 binop(op2, mkexpr(arg_n), mkU64(imm)),
5653 binop(op2, mkexpr(arg_m), mkU64(imm))),
5742 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5745 binop(op2, mkexpr(arg_n),
5747 binop(op2, mkexpr(arg_m),
5753 putQReg(dreg, mkexpr(res), condT);
5755 putDRegI64(dreg, mkexpr(res), condT);
5842 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5845 binop(op2, mkexpr(arg_n),
5847 binop(op2, mkexpr(arg_m),
5853 putQReg(dreg, mkexpr(res), condT);
5855 putDRegI64(dreg, mkexpr(res), condT);
5982 mkexpr(reg_m),
5986 mkexpr(reg_m),
6000 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6003 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6011 putQReg(dreg, mkexpr(res), condT);
6013 putDRegI64(dreg, mkexpr(res), condT);
6074 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6077 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6080 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6087 putQReg(dreg, mkexpr(res), condT);
6089 putDRegI64(dreg, mkexpr(res), condT);
6122 mkexpr(mask))),
6126 putQReg(dreg, mkexpr(res), condT);
6134 mkexpr(mask))),
6138 putDRegI64(dreg, mkexpr(res), condT);
6171 mkexpr(mask))),
6175 putQReg(dreg, mkexpr(res), condT);
6183 mkexpr(mask))),
6187 putDRegI64(dreg, mkexpr(res), condT);
6211 putQReg(dreg, mkexpr(res), condT);
6213 putDRegI64(dreg, mkexpr(res), condT);
6313 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6315 assign(tmp, binop(op_rev, mkexpr(res), mkU8(shift_imm)));
6316 setFlag_QC(mkexpr(tmp), mkexpr(reg_m), Q, condT);
6319 putQReg(dreg, mkexpr(res), condT);
6321 putDRegI64(dreg, mkexpr(res), condT);
6357 mkexpr(reg_m),
6359 putDRegI64(dreg, mkexpr(res), condT);
6401 mkexpr(reg_m),
6405 mkexpr(reg_m),
6408 putDRegI64(dreg, mkexpr(res), condT);
6497 binop(op, mkexpr(reg_m), mkU8(shift_imm)),
6500 mkexpr(reg_m),
6505 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6508 setFlag_QC(unop(cvt2, unop(cvt, mkexpr(res))), mkexpr(res),
6511 putDRegI64(dreg, unop(cvt, mkexpr(res)), condT);
6542 putQReg(dreg, mkexpr(res), condT);
6635 assign(res, unop(op, mkexpr(arg_m)));
6656 assign(res, unop(op, mkexpr(arg_m)));
6675 assign(res, unop(op, mkexpr(arg_m)));
6704 assign(res, unop(op, mkexpr(arg_m)));
6722 assign(res, unop(op, mkexpr(arg_m)));
6737 assign(res, unop(op, mkexpr(arg_m)));
6744 assign(res, unop(Q ? Iop_Cnt8x16 : Iop_Cnt8x8, mkexpr(arg_m)));
6751 assign(res, unop(Iop_NotV128, mkexpr(arg_m)));
6753 assign(res, unop(Iop_Not64, mkexpr(arg_m)));
6808 assign(res, binop(add_op, unop(op, mkexpr(arg_m)),
6809 mkexpr(arg_d)));
6852 assign(mask, binop(op_cmp, mkexpr(arg_m), zero1));
6853 neg = binop(op_qsub, zero2, mkexpr(arg_m));
6854 neg2 = binop(op_sub, zero2, mkexpr(arg_m));
6857 mkexpr(mask),
6858 mkexpr(arg_m)),
6861 mkexpr(mask)),
6866 mkexpr(mask),
6867 mkexpr(arg_m)),
6870 mkexpr(mask)),
6872 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
6905 assign(res, binop(op, zero, mkexpr(arg_m)));
6907 setFlag_QC(mkexpr(res), binop(op2, zero, mkexpr(arg_m)),
6918 putQReg(dreg, mkexpr(res), condT);
6920 putDRegI64(dreg, mkexpr(res), condT);
6958 assign(res, binop(op, mkexpr(arg_m), zero));
6978 assign(res, binop(op, mkexpr(arg_m), zero));
6988 binop(op, zero, mkexpr(arg_m))));
7009 assign(res, binop(op, zero, mkexpr(arg_m)));
7019 unop(op, mkexpr(arg_m))));
7040 assign(res, binop(op, zero, mkexpr(arg_m)));
7050 binop(op, mkexpr(arg_m), zero)));
7071 assign(res, binop(op, zero, mkexpr(arg_m)));
7080 assign(res, binop(op, zero, mkexpr(arg_m)));
7099 assign(res, unop(op, mkexpr(arg_m)));
7102 mkexpr(arg_m)));
7119 assign(res, unop(op, mkexpr(arg_m)));
7133 assign(res, binop(op, zero, mkexpr(arg_m)));
7144 putQReg(dreg, mkexpr(res), condT);
7146 putDRegI64(dreg, mkexpr(res), condT);
7156 putQReg(dreg, mkexpr(arg_m), condT);
7161 putDRegI64(dreg, mkexpr(arg_m), condT);
7224 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7225 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7227 putQReg(dreg, mkexpr(res1), condT);
7228 putQReg(mreg, mkexpr(res2), condT);
7230 putDRegI64(dreg, mkexpr(res1), condT);
7231 putDRegI64(mreg, mkexpr(res2), condT);
7275 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7276 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7278 putQReg(dreg, mkexpr(res1), condT);
7279 putQReg(mreg, mkexpr(res2), condT);
7281 putDRegI64(dreg, mkexpr(res1), condT);
7282 putDRegI64(mreg, mkexpr(res2), condT);
7326 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7327 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7329 putQReg(dreg, mkexpr(res1), condT);
7330 putQReg(mreg, mkexpr(res2), condT);
7332 putDRegI64(dreg, mkexpr(res1), condT);
7333 putDRegI64(mreg, mkexpr(res2), condT);
7409 setFlag_QC(mkexpr(res), mkexpr(tmp), False, condT);
7411 putDRegI64(dreg, mkexpr(res), condT);
7433 putQReg(dreg, mkexpr(res), condT);
7730 expr = binop(Iop_OrV128, mkexpr(tmp_var), imm_val);
7732 expr = binop(Iop_Or64, mkexpr(tmp_var), imm_val);
7737 expr = binop(Iop_AndV128, mkexpr(tmp_var),
7740 expr = binop(Iop_And64, mkexpr(tmp_var), unop(Iop_Not64, imm_val));
7815 loadLE(Ity_I8, mkexpr(addr))), IRTemp_INVALID);
7819 loadLE(Ity_I16, mkexpr(addr))), IRTemp_INVALID);
7823 loadLE(Ity_I32, mkexpr(addr))), IRTemp_INVALID);
7836 mkexpr(addr),
7846 mkexpr(addr),
7856 mkexpr(addr),
7875 storeLE(mkexpr(addr),
7879 storeLE(mkexpr(addr),
7883 storeLE(mkexpr(addr),
7892 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 1)),
7897 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 2)),
7902 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 4)),
7961 assign(addr, mkexpr(initialRn));
8010 assign(addr, mkexpr(initialRn));
8019 loadLE(Ity_I8, mkexpr(addr))),
8024 loadLE(Ity_I16, mkexpr(addr))),
8029 loadLE(Ity_I32, mkexpr(addr))),
8041 mkexpr(addr),
8049 mkexpr(addr),
8057 mkexpr(addr),
8085 mkexpr(initialRn),
8093 mkexpr(initialRn),
8094 mkexpr(initialRm));
8146 assign(addr, mkexpr(initialRn));
8155 assign(tmp, binop(Iop_Add32, mkexpr(addr),
8164 mkexpr(initialRn),
8172 mkexpr(initialRn),
8173 mkexpr(initialRm));
8381 assign( res, binop(Iop_Mul32, mkexpr(srcN), mkexpr(srcM)) );
8384 putIRegT( regD, mkexpr(res), condT );
8386 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8438 unop(Iop_64HIto32, mkexpr(irt_prod)),
8441 unop(Iop_64to32, mkexpr(irt_prod)),
8500 binop(Iop_And32, mkexpr(irt_regM_shift), mkU32(mask)),
8561 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
8564 putIRegT( regD, mkexpr(irt_result), condT );
8566 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
8619 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
8622 putIRegT( regD, mkexpr(irt_result), condT );
8624 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
8669 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
8671 assign( irt_regN_hi, binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)) );
8674 or_into_QFLAG32( mkexpr(irt_Q_lo), condT );
8677 or_into_QFLAG32( mkexpr(irt_Q_hi), condT );
8680 binop(Iop_Shl32, mkexpr(irt_res_hi), mkU8(16)),
8681 mkexpr(irt_res_lo) );
8728 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
8730 putIRegT( regD, mkexpr(res), condT );
8732 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8734 assign(reso, binop(Iop_HAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
8777 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
8779 putIRegT( regD, mkexpr(res), condT );
8781 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8784 binop(Iop_HAdd16Sx2, mkexpr(rNt), mkexpr(rMt))));
8827 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
8829 putIRegT( regD, mkexpr(res), condT );
8831 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8834 binop(Iop_HSub16Ux2, mkexpr(rNt), mkexpr(rMt))));
8877 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
8879 putIRegT( regD, mkexpr(res), condT );
8881 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8884 binop(Iop_HSub16Sx2, mkexpr(rNt), mkexpr(rMt))));
8927 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
8929 putIRegT( regD, mkexpr(res), condT );
8931 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8933 assign(reso, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
8976 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
8978 putIRegT( regD, mkexpr(res), condT );
8980 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8983 binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt))));
9026 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9028 putIRegT( regD, mkexpr(res), condT );
9030 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9033 binop(Iop_HSub8Ux4, mkexpr(rNt), mkexpr(rMt))));
9076 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9078 putIRegT( regD, mkexpr(res), condT );
9080 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9083 binop(Iop_HSub8Sx4, mkexpr(rNt), mkexpr(rMt))));
9125 assign(res_q, binop(Iop_QAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
9127 putIRegT( regD, mkexpr(res_q), condT );
9129 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9170 assign(res_q, binop(Iop_QSub8Sx4, mkexpr(rNt), mkexpr(rMt)));
9172 putIRegT( regD, mkexpr(res_q), condT );
9174 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9215 assign(res_q, binop(Iop_QAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9217 putIRegT( regD, mkexpr(res_q), condT );
9219 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9260 assign(res_q, binop(Iop_QSub8Ux4, mkexpr(rNt), mkexpr(rMt)));
9262 putIRegT( regD, mkexpr(res_q), condT );
9264 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9305 assign(res_q, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9307 putIRegT( regD, mkexpr(res_q), condT );
9309 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9350 assign(res_q, binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
9352 putIRegT( regD, mkexpr(res_q), condT );
9354 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9395 assign(res_q, binop(Iop_QAdd16Sx2, mkexpr(rNt), mkexpr(rMt)));
9397 putIRegT( regD, mkexpr(res_q), condT );
9399 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9440 assign(res_q, binop(Iop_QSub16Sx2, mkexpr(rNt), mkexpr(rMt)));
9442 putIRegT( regD, mkexpr(res_q), condT );
9444 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9498 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9500 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
9507 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9509 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) )) );
9513 binop( Iop_Shl32, mkexpr(irt_diff_res),
9515 binop( Iop_And32, mkexpr(irt_sum_res),
9568 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9570 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9575 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9577 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9583 binop( Iop_Shl32, mkexpr(irt_res_sum), mkU8(16) ),
9584 binop( Iop_And32, mkexpr(irt_res_diff), mkU32(0xFFFF) ) );
9634 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9636 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9640 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9642 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9647 binop( Iop_Shl32, mkexpr(irt_sum), mkU8(16) ),
9648 binop( Iop_And32, mkexpr(irt_diff), mkU32(0xFFFF) ) );
9651 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
9652 put_GEFLAG32( 0, 31, mkexpr(ge10), condT );
9653 put_GEFLAG32( 1, 31, mkexpr(ge10), condT );
9656 assign(ge32, unop(Iop_Not32, mkexpr(irt_sum)));
9657 put_GEFLAG32( 2, 31, mkexpr(ge32), condT );
9658 put_GEFLAG32( 3, 31, mkexpr(ge32), condT );
9717 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
9720 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
9723 binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)),
9724 binop(Iop_Sar32, mkexpr(irt_regM), mkU8(16))) );
9727 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) );
9801 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9804 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9808 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9809 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9811 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) ) );
9813 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_sum), mkexpr(irt_regA));
9822 signed_overflow_after_Add32( mkexpr(irt_sum),
9891 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_prod), mkexpr(irt_regA));
9958 binop(Iop_Shl32, unop(Iop_64HIto32, mkexpr(irt_prod)), mkU8(16)),
9959 binop(Iop_Shr32, unop(Iop_64to32, mkexpr(irt_prod)), mkU8(16))
9962 IRExpr* ire_result = binop(Iop_Add32, mkexpr(prod32), mkexpr(irt_regA));
10021 = binop(Iop_Or32, mkexpr(irt_ge_flag0),
10022 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag0)));
10024 = binop(Iop_Or32, mkexpr(irt_ge_flag1),
10025 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag1)));
10027 = binop(Iop_Or32, mkexpr(irt_ge_flag2),
10028 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag2)));
10030 = binop(Iop_Or32, mkexpr(irt_ge_flag3),
10031 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag3)));
10110 binop(Iop_Add32, mkexpr(irt_regN), mkexpr(irt_rot)),
10115 binop(Iop_And32, mkexpr(irt_regN), mkU32(0xFFFF0000)),
10116 binop(Iop_And32, mkexpr(irt_rot), mkU32(0xFFFF0000)));
10232 /* assign(anchorT, binop(Iop_And32, mkexpr(oldRnT), mkU32(~3U))); */
10234 assign(anchorT, mkexpr(oldRnT));
10253 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
10345 binop(opADDorSUB, mkexpr(anchorT),
10359 storeLE( binop(opADDorSUB, mkexpr(anchorT), mkU32(xOff[i])),
10360 r == rN ? mkexpr(oldRnT)
10368 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
10515 mkexpr(rnT),
10521 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
10528 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
10530 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
10535 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
10548 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
10550 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
10652 mkexpr(rnT),
10658 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
10665 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
10667 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
10672 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
10685 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
10687 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
10787 IRExpr* hi32 = unop(Iop_64HIto32, mkexpr(i64));
10788 IRExpr* lo32 = unop(Iop_64to32, mkexpr(i64));
11055 putDReg(dD, loadLE(Ity_F64,mkexpr(ea)), IRTemp_INVALID);
11057 storeLE(mkexpr(ea), getDReg(dD));
11177 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
11202 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
11203 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
11205 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
11296 : mkexpr(mk_get_IR_rounding_mode()));
11300 binop(Iop_F64toI32S, mkexpr(rmode),
11308 binop(Iop_F64toI32U, mkexpr(rmode),
11401 mkexpr(rnT),
11407 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
11414 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11416 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11421 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(4*i));
11434 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11436 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11517 putFReg(fD, loadLE(Ity_F32,mkexpr(ea)), IRTemp_INVALID);
11519 storeLE(mkexpr(ea), getFReg(fD));
11645 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
11670 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
11671 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
11673 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
11746 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
11750 mkexpr(rmode),
11758 mkexpr(rmode),
11780 : mkexpr(mk_get_IR_rounding_mode()));
11784 binop(Iop_F64toI32S, mkexpr(rmode),
11793 binop(Iop_F64toI32U, mkexpr(rmode),
11826 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
11827 putFReg(fD, binop(Iop_F64toF32, mkexpr(rmode), getDReg(dM)),
12204 assign(res, binop(op, mkexpr(shop), mkexpr(rNt)) );
12208 assign(res, binop(op, mkexpr(rNt),
12209 unop(Iop_Not32, mkexpr(shop))) );
12212 assign(res, binop(op, mkexpr(rNt), mkexpr(shop)) );
12223 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
12271 assign( res, isMVN ? unop(Iop_Not32, mkexpr(shop))
12272 : mkexpr(shop) );
12281 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
12338 mkexpr(rNt), mkexpr(shop)) );
12375 binop(Iop_Add32, mkexpr(rNt), mkexpr(shop)),
12376 mkexpr(oldC) ));
12381 binop(Iop_Sub32, mkexpr(rNt), mkexpr(shop)),
12382 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
12387 binop(Iop_Sub32, mkexpr(shop), mkexpr(rNt)),
12388 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
12396 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
12567 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
12573 storeLE( mkexpr(taT), mkexpr(rDt) );
12576 storeLE( mkexpr(taT), unop(Iop_32to8, mkexpr(rDt)) );
12585 putIRegA( rD, loadLE(Ity_I32, mkexpr(taT)),
12589 putIRegA( rD, unop(Iop_8Uto32, loadLE(Ity_I8, mkexpr(taT))),
12599 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
12780 storeLE( mkexpr(taT), unop(Iop_32to16, getIRegA(rD)) );
12784 mkexpr(taT))),
12789 putIRegA( rD, unop(Iop_16Sto32, loadLE(Ity_I16, mkexpr(taT))),
12794 putIRegA( rD, unop(Iop_8Sto32, loadLE(Ity_I8, mkexpr(taT))),
12807 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
12944 unop(Iop_32to1, mkexpr(condT))),
12963 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
12974 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
13039 unop(Iop_1Uto8,binop(Iop_CmpEQ32, mkexpr(arg),
13041 unop(Iop_Clz32, mkexpr(arg)),
13044 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13068 assign( res, binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) );
13076 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
13080 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13081 mkexpr(oldV)) );
13118 mkexpr(argP),
13119 binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) ));
13128 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
13132 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13133 mkexpr(oldV)) );
13166 assign( res, binop(mulOp, mkexpr(argL), mkexpr(argR)) );
13167 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
13168 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
13176 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
13177 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
13181 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13182 mkexpr(oldV)) );
13218 mkexpr(old),
13219 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
13220 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
13221 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
13229 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
13230 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
13234 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13235 mkexpr(oldV)) );
13291 putIRegA( rD, mkexpr(apsr), condT, Ijk_Boring );
13345 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
13347 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
13348 unop(Iop_32to8, mkexpr(tNew))) );
13352 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
13354 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
13355 mkexpr(tNew)) );
13357 stmt( IRStmt_Exit(unop(Iop_Not1, mkexpr(tSC1)),
13360 putIRegA(rD, isB ? unop(Iop_8Uto32, mkexpr(tOld)) : mkexpr(tOld),
13392 putIRegA(rT, mkexpr(res), IRTemp_INVALID, Ijk_Boring);
13424 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
13426 putIRegA(rD, mkexpr(resSC32),
13480 assign(dstT, unop(Iop_8Uto32, unop(Iop_32to8, mkexpr(rotT))));
13484 assign(dstT, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rotT))));
13488 assign(dstT, unop(Iop_16Uto32, unop(Iop_32to16, mkexpr(rotT))));
13492 assign(dstT, unop(Iop_16Sto32, unop(Iop_32to16, mkexpr(rotT))));
13496 assign(dstT, binop(Iop_And32, mkexpr(rotT), mkU32(0x00FF00FF)));
13502 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
13503 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
13509 unop(Iop_32to8, mkexpr(lo32))),
13513 unop(Iop_32to8, mkexpr(hi32))),
13522 putIRegA(rD, mkexpr(dstT), condT, Ijk_Boring);
13552 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
13555 mkexpr(olddst),
13559 putIRegA(rD, mkexpr(newdst), condT, Ijk_Boring);
13594 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
13597 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
13600 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13745 storeLE( binop(Iop_Add32, mkexpr(taT), mkU32(0)), getIRegA(rD+0) );
13746 storeLE( binop(Iop_Add32, mkexpr(taT), mkU32(4)), getIRegA(rD+1) );
13750 loadLE(Ity_I32, binop(Iop_Add32, mkexpr(taT), mkU32(0))),
13753 loadLE(Ity_I32, binop(Iop_Add32, mkexpr(taT), mkU32(4))),
13766 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
13805 mkexpr(srcL),
13809 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13835 mkexpr(srcL),
13839 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13858 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13873 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13976 putIRegA(rT+0, unop(Iop_64HIto32, mkexpr(res)), IRTemp_INVALID, Ijk_Boring);
13977 putIRegA(rT+1, unop(Iop_64to32, mkexpr(res)), IRTemp_INVALID, Ijk_Boring);
14006 stmt( IRStmt_LLSC(Iend_LE, resSC1, getIRegA(rN), mkexpr(data)) );
14012 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
14014 putIRegA(rD, mkexpr(resSC32),
14122 mkexpr(r15guard), mkU32(1))),
14392 // binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
14410 // binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
14424 // mkexpr(old_itstate),
14427 // mkexpr(condT1)
14440 // binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
14449 // binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
14460 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
14475 binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
14499 we can simply do "assign(condT, mkexpr(condT1))", and the
14505 mkexpr(old_itstate),
14508 mkexpr(condT1)
14518 binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
14527 binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
14614 putIRegT(rD, binop(Iop_Sub32, mkexpr(zero), mkexpr(arg)), condT);
14632 putIRegT(rD, mkexpr(res), condT);
14663 putIRegT(rD, mkexpr(res), condT);
14684 putIRegT(rD, mkexpr(res), condT);
14704 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
14705 mkexpr(oldC)));
14707 putIRegT(rD, mkexpr(res), condT);
14727 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
14728 binop(Iop_Xor32, mkexpr(oldC), mkU32(1))));
14730 putIRegT(rD, mkexpr(res), condT);
14835 putIRegT(rD, mkexpr(res), condT);
14852 putIRegT(rD, mkexpr(res), condT);
14903 irsb->next = mkexpr(dst);
14927 irsb->next = mkexpr(dst);
14983 putIRegT( rD, mkexpr(res), condT );
14992 irsb->next = binop(Iop_Or32, mkexpr(res), mkU32(1));
15033 putIRegT( rD, mkexpr(val), condT );
15042 irsb->next = binop(Iop_Or32, mkexpr(val), mkU32(1));
15097 stmt(IRStmt_Exit( mkexpr(kond),
15147 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
15152 assign(base, binop(Iop_And32, mkexpr(newSP), mkU32(~3)));
15158 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(4 * nRegs)),
15202 assign(base, binop(Iop_And32, mkexpr(oldSP), mkU32(~3)));
15208 assign(newSP, binop(Iop_Add32, mkexpr(oldSP),
15216 binop(Iop_Add32, mkexpr(base),
15227 binop(Iop_Add32, mkexpr(base),
15232 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
15243 irsb->next = mkexpr(newPC);
15267 mkexpr(argL), mkexpr(argR)),
15288 mkexpr(argL), mkexpr(argR)),
15443 mkexpr(argL), mkexpr(argR)), condT );
15498 putIRegT(rD, mkexpr(res), condT);
15520 putIRegT(rD, loadLE(Ity_I32, mkexpr(ea)),
15652 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
15659 binop(Iop_Add32, mkexpr(base),
15668 binop(Iop_Add32, mkexpr(oldRn),
15706 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
15711 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(nRegs * 4 - 4)),
15716 binop(Iop_Add32, mkexpr(oldRn),
15770 putIRegT(rD, mkexpr(res), condT);
15819 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
16015 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
16016 putIRegT(rD, mkexpr(res), condT);
16045 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
16046 putIRegT(rD, mkexpr(res), condT);
16094 mkexpr(argL), mkexpr(argR)));
16127 ? binop(Iop_Sub32, mkexpr(argR), mkexpr(argL))
16128 : binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
16129 putIRegT(rD, mkexpr(res), condT);
16158 assign(res, binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
16159 putIRegT(rD, mkexpr(res), condT);
16181 assign(res, binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
16182 putIRegT(rD, mkexpr(res), condT);
16218 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
16219 mkexpr(oldC) ));
16220 putIRegT(rD, mkexpr(res), condT);
16229 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
16230 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
16231 putIRegT(rD, mkexpr(res), condT);
16280 assign(res, binop(op, mkexpr(argL), mkexpr(argR)));
16281 putIRegT(rD, mkexpr(res), condT);
16349 ? binop(op, mkexpr(argR), mkexpr(argL))
16350 : binop(op, mkexpr(argL), mkexpr(argR)));
16352 putIRegT(rD, mkexpr(res), condT);
16412 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
16413 mkexpr(oldC) ));
16414 putIRegT(rD, mkexpr(res), condT);
16423 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
16424 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
16425 putIRegT(rD, mkexpr(res), condT);
16489 assign(res, binop(op, mkexpr(rNt),
16490 unop(Iop_Not32, mkexpr(argR))));
16492 assign(res, binop(op, mkexpr(rNt), mkexpr(argR)));
16495 putIRegT(rD, mkexpr(res), condT);
16539 putIRegT(rD, mkexpr(res), condT);
16572 assign(res, isMVN ? unop(Iop_Not32, mkexpr(oldRn))
16573 : mkexpr(oldRn));
16575 putIRegT(rD, mkexpr(res), condT);
16619 mkexpr(argL), mkexpr(argR)));
16676 putIRegT(rD, mkexpr(res), condT);
16720 putIRegT(rD, mkexpr(res), condT);
16806 mkexpr(preAddr), mkU32(imm8)));
16829 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
16835 storeLE(mkexpr(transAddr),
16836 unop(Iop_32to8, mkexpr(oldRt)));
16839 storeLE(mkexpr(transAddr),
16840 unop(Iop_32to16, mkexpr(oldRt)));
16843 storeLE(mkexpr(transAddr), mkexpr(oldRt));
16867 assign(newRt, loadLE(ty, mkexpr(transAddr)));
16869 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
16873 llPutIReg(rT, mkexpr(newRt));
16875 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
16880 irsb->next = mkexpr(newRt);
16888 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
16990 storeLE(mkexpr(transAddr),
16991 unop(Iop_32to8, mkexpr(oldRt)));
16994 storeLE(mkexpr(transAddr),
16995 unop(Iop_32to16, mkexpr(oldRt)));
16998 storeLE(mkexpr(transAddr), mkexpr(oldRt));
17017 assign(newRt, loadLE(ty, mkexpr(transAddr)));
17019 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
17028 llPutIReg(rT, mkexpr(newRt));
17030 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17035 irsb->next = mkexpr(newRt);
17129 binop( Iop_Add32, mkexpr(rNt), mkU32(imm12) ));
17136 storeLE(mkexpr(transAddr),
17137 unop(Iop_32to8, mkexpr(oldRt)));
17140 storeLE(mkexpr(transAddr),
17141 unop(Iop_32to16, mkexpr(oldRt)));
17144 storeLE(mkexpr(transAddr), mkexpr(oldRt));
17163 assign(newRt, loadLE(ty, mkexpr(transAddr)));
17165 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
17167 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17171 irsb->next = mkexpr(newRt);
17217 mkexpr(preAddr), mkU32(imm8 << 2)));
17226 storeLE(mkexpr(transAddr),
17227 mkexpr(oldRt));
17228 storeLE(binop(Iop_Add32, mkexpr(transAddr), mkU32(4)),
17229 mkexpr(oldRt2));
17235 mkexpr(transAddr)));
17238 binop(Iop_Add32, mkexpr(transAddr), mkU32(4))));
17239 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17240 putIRegT(rT2, mkexpr(newRt2), IRTemp_INVALID);
17244 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
17291 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
17375 binop(Iop_Shl32, mkexpr(delta), mkU8(1))
17411 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
17414 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
17417 putIRegT(rD, mkexpr(res), condT);
17455 unop(Iop_32to8, mkexpr(rotT))));
17460 unop(Iop_32to16, mkexpr(rotT))));
17465 unop(Iop_32to8, mkexpr(rotT))));
17470 unop(Iop_32to16, mkexpr(rotT))));
17474 assign(dstT, binop(Iop_And32, mkexpr(rotT),
17481 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
17482 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
17488 unop(Iop_32to8, mkexpr(lo32))),
17492 unop(Iop_32to8, mkexpr(hi32))),
17500 putIRegT(rD, mkexpr(dstT), condT);
17515 putIRegT(rD, mkexpr(res), condT);
17534 putIRegT( rDhi, unop(Iop_64HIto32, mkexpr(res)), condT );
17535 putIRegT( rDlo, unop(Iop_64to32, mkexpr(res)), condT );
17558 putIRegT(rD, mkexpr(res), condT);
17605 mkexpr(old),
17606 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
17607 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
17608 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
17609 putIRegT( rDhi, mkexpr(resHi), condT );
17610 putIRegT( rDlo, mkexpr(resLo), condT );
17657 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
17660 mkexpr(olddst),
17664 putIRegT(rD, mkexpr(newdst), condT);
17695 mkexpr(srcL),
17699 putIRegT(rD, mkexpr(res), condT);
17724 mkexpr(srcL),
17728 putIRegT(rD, mkexpr(res), condT);
17748 mkexpr(arg),
17750 unop(Iop_Clz32, mkexpr(arg)),
17753 putIRegT(rD, mkexpr(res), condT);
17770 putIRegT(rD, mkexpr(res), condT);
17790 putIRegT(rD, mkexpr(res), condT);
17818 putIRegT( rD, mkexpr(apsr), condT );
17839 putIRegT(rT, mkexpr(res), IRTemp_INVALID);
17870 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
17872 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
18065 mkexpr(r15guard), mkU32(1))),
