Lines Matching defs:mkexpr
293 static IRExpr* mkexpr ( IRTemp tmp )
341 binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0))) );
373 binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0))) );
396 return mkexpr(src);
399 binop(Iop_Shl32, mkexpr(src), mkU8(32 - rot)),
400 binop(Iop_Shr32, mkexpr(src), mkU8(rot)));
599 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
632 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
727 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
770 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
836 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
895 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
924 IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
941 stmt( IRStmt_Put( OFFB_ITSTATE, mkexpr(t)) );
953 putMiscReg32( OFFB_QFLAG32, mkexpr(t), condT );
964 assign(nyu, binop(Iop_Or32, mkexpr(old), e) );
992 case 0: putMiscReg32(OFFB_GEFLAG0, mkexpr(masked), condT); break;
993 case 1: putMiscReg32(OFFB_GEFLAG1, mkexpr(masked), condT); break;
994 mkexpr(masked), condT); break;
995 case 3: putMiscReg32(OFFB_GEFLAG3, mkexpr(masked), condT); break;
1020 assign(ge10, binop(Iop_And32, mkexpr(t32), mkU32(0x00008000)));
1021 assign(ge32, binop(Iop_And32, mkexpr(t32), mkU32(0x80000000)));
1022 put_GEFLAG32( 0, 0, mkexpr(ge10), condT );
1023 put_GEFLAG32( 1, 0, mkexpr(ge10), condT );
1024 put_GEFLAG32( 2, 0, mkexpr(ge32), condT );
1025 put_GEFLAG32( 3, 0, mkexpr(ge32), condT );
1038 assign(ge0, binop(Iop_And32, mkexpr(t32), mkU32(0x00000080)));
1039 assign(ge1, binop(Iop_And32, mkexpr(t32), mkU32(0x00008000)));
1040 assign(ge2, binop(Iop_And32, mkexpr(t32), mkU32(0x00800000)));
1041 assign(ge3, binop(Iop_And32, mkexpr(t32), mkU32(0x80000000)));
1042 put_GEFLAG32( 0, 0, mkexpr(ge0), condT );
1043 put_GEFLAG32( 1, 0, mkexpr(ge1), condT );
1044 put_GEFLAG32( 2, 0, mkexpr(ge2), condT );
1045 put_GEFLAG32( 3, 0, mkexpr(ge3), condT );
1080 binop(Iop_Shl32, mkexpr(armEncd), mkU8(1)),
1083 binop(Iop_Shr32, mkexpr(armEncd), mkU8(1)),
1323 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t_dep1) ));
1324 stmt( IRStmt_Put( OFFB_CC_DEP2, mkexpr(t_dep2) ));
1325 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(t_ndep) ));
1329 assign( c1, binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)) );
1332 IRExpr_ITE( mkexpr(c1),
1337 IRExpr_ITE( mkexpr(c1),
1338 mkexpr(t_dep1),
1342 IRExpr_ITE( mkexpr(c1),
1343 mkexpr(t_dep2),
1347 IRExpr_ITE( mkexpr(c1),
1348 mkexpr(t_ndep),
1405 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1422 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1440 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1458 binop(Iop_CmpNE32, mkexpr(t), mkU32(0)),
1483 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
1514 mkexpr(res1),
1518 mkexpr(get_QFLAG32()),
1534 mkexpr(res2),
1555 assign(immT, binop(Iop_And32, mkexpr(apsrT), mkU32(0xF0000000)) );
1559 assign(qnewT, binop(Iop_And32, mkexpr(apsrT), mkU32(ARMG_CC_MASK_Q)));
1564 put_GEFLAG32(0, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<16)),
1566 put_GEFLAG32(1, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<17)),
1568 put_GEFLAG32(2, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<18)),
1570 put_GEFLAG32(3, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<19)),
1612 assign( nd0, mkexpr(regT) );
1614 assign( nd2, binop( Iop_CmpLT32S, mkexpr(nd1), mkexpr(nd0) ) );
1615 assign( nd3, IRExpr_ITE(mkexpr(nd2), mkexpr(nd1), mkexpr(nd0)) );
1617 assign( nd5, binop( Iop_CmpLT32S, mkexpr(nd3), mkexpr(nd4) ) );
1618 assign( nd6, IRExpr_ITE(mkexpr(nd5), mkexpr(nd4), mkexpr(nd3)) );
1619 assign( *res, mkexpr(nd6) );
1624 assign( *resQ, binop(Iop_Xor32, mkexpr(*res), mkexpr(regT)) );
1656 assign( nd0, mkexpr(regT) );
1658 assign( nd2, binop( Iop_CmpLT32S, mkexpr(nd1), mkexpr(nd0) ) );
1659 assign( nd3, IRExpr_ITE( mkexpr(nd2), mkexpr(nd1), mkexpr(nd0) ) );
1661 assign( nd5, binop( Iop_CmpLT32S, mkexpr(nd3), mkexpr(nd4) ) );
1662 assign( nd6, IRExpr_ITE( mkexpr(nd5), mkexpr(nd4), mkexpr(nd3) ) );
1663 assign( *res, mkexpr(nd6) );
1668 assign( *resQ, binop(Iop_Xor32, mkexpr(*res), mkexpr(regT)) );
1685 binop( Iop_Xor32, mkexpr(res), mkexpr(argL) ),
1686 binop( Iop_Xor32, mkexpr(res), mkexpr(argR) )),
1700 binop( Iop_Xor32, mkexpr(argL), mkexpr(argR) ),
1701 binop( Iop_Xor32, mkexpr(res), mkexpr(argL) )),
1741 assign( *res, mkexpr(rMt) );
1748 binop(Iop_Shr32, mkexpr(rMt),
1753 binop(Iop_Shl32, mkexpr(rMt), mkU8(shift_amt)) );
1773 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1788 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0)),
1789 mkexpr(oldC),
1791 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32)),
1794 mkexpr(rMt),
1799 mkexpr(amtT)),
1820 mkexpr(rMt),
1822 binop(Iop_And32, mkexpr(rSt), mkU32(31)))),
1825 mkexpr(amtT),
1847 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1860 binop(Iop_Shr32, mkexpr(rMt),
1865 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)) );
1885 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1898 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0)),
1899 mkexpr(oldC),
1901 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32)),
1904 mkexpr(rMt),
1908 mkexpr(amtT),
1930 mkexpr(rMt),
1932 binop(Iop_And32, mkexpr
1935 mkexpr(amtT),
1957 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1960 assign( *res, binop(Iop_Sar32, mkexpr(rMt), mkU8(31)) );
1970 binop(Iop_Shr32, mkexpr(rMt),
1975 binop(Iop_Sar32, mkexpr(rMt), mkU8(shift_amt)) );
1995 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
2008 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0)),
2009 mkexpr(oldC),
2011 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32)),
2014 mkexpr(rMt),
2018 mkexpr(amtT),
2028 mkexpr(rMt),
2042 mkexpr(rMt),
2046 binop(Iop_CmpLT32U, mkexpr(amtT), mkU32(32)),
2047 mkexpr(amtT),
2066 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
2068 assign( amt5T, binop(Iop_And32, mkexpr(rSt), mkU32(31)) );
2075 binop(Iop_CmpNE32, mkexpr(amtT), mkU32(0)),
2078 mkexpr(rMt),
2082 mkexpr(amtT),
2091 mkexpr(oldC)
2098 binop(Iop_CmpNE32, mkexpr(amt5T), mkU32(0)),
2101 mkexpr(rMt),
2102 unop(Iop_32to8, mkexpr(amt5T))
2105 mkexpr(rMt),
2107 binop(Iop_Sub32, mkU32(32), mkexpr(amt5T))
2111 mkexpr(rMt)
2175 binop(Iop_And32, mkexpr(rMt), mkU32(1)));
2180 binop(Iop_Shl32, mkexpr(oldcT), mkU8(31)),
2181 binop(Iop_Shr32, mkexpr(rMt), mkU8(1))) );
2191 binop(Iop_Shr32, mkexpr(rMt),
2197 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)),
2198 binop(Iop_Shl32, mkexpr(rMt),
2434 binop(Iop_Shl32, mkexpr(cflagT), mkU8(31)),
2435 binop(Iop_Shr32, mkexpr(rmT), mkU8(1)));
2442 binop(Iop_Shl32, mkexpr(rmT), mkU8(32-imm5)),
2443 binop(Iop_Shr32, mkexpr(rmT), mkU8(imm5)));
2535 binop(Iop_Shr32, mkexpr(irRes), mkU8(5)),
2537 binop(Iop_And32, mkexpr(irRes), mkU32(1))));
2545 binop(Iop_Xor32, mkexpr(ix), mkU32(1)),
2555 mkexpr(ix),
2556 binop(Iop_Shr32, mkexpr(ix), mkU8(1))),
2559 assign(nzcv, binop(Iop_Sub32, mkexpr(termL), mkexpr(termR)));
2716 binop(Iop_And32, mkexpr(x0), mkU32(c1)),
2719 binop(Iop_And32, mkexpr(x0), mkU32(~c1)),
2725 binop(Iop_And32, mkexpr(x1), mkU32(c2)),
2728 binop(Iop_And32, mkexpr(x1), mkU32(~c2)),
2734 binop(Iop_And32, mkexpr(x2), mkU32(c3)),
2737 binop(Iop_And32, mkexpr(x2), mkU32(~c3)),
2743 binop(Iop_And32, mkexpr(x3), mkU32(c4)),
2746 binop(Iop_And32, mkexpr(x3), mkU32(~c4)),
2752 binop(Iop_And32, mkexpr(x4), mkU32(c5)),
2755 binop(Iop_And32, mkexpr(x4), mkU32(~c5)),
2769 binop(Iop_Shl32, mkexpr(arg), mkU8(24)),
2771 binop(Iop_And32, binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2774 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2776 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(24)),
2791 binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2794 binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2945 assign(new_arg, binop(Iop_Sub8x8, mkexpr(old_arg), mkU64(imm)));
2946 assign(cur_mask, binop(cmp, mkU64(imm), mkexpr(old_arg)));
2947 assign(new_mask, binop(Iop_Or64, mkexpr(old_mask), mkexpr(cur_mask)));
2949 mkexpr(old_res),
2952 mkexpr(arg_l),
2954 mkexpr(old_arg),
2955 mkexpr(cur_mask))),
2956 mkexpr(cur_mask))));
2967 unop(Iop_Not64, mkexpr(old_mask))),
2968 mkexpr(old_res)));
2972 putDRegI64(dreg, mkexpr(old_res), condT);
3027 assign(res, unop(op, binop(op2, mkexpr(arg_m), mkU8(index))));
3029 putQReg(dreg, mkexpr(res), condT);
3031 putDRegI64(dreg, mkexpr(res), condT);
3133 binop(shOp, mkexpr(arg_m), mkU8(1)),
3134 binop(shOp, mkexpr(arg_n), mkU8(1))),
3137 binop(andOp, mkexpr(arg_m), imm_val),
3138 binop(andOp, mkexpr(arg_n), imm_val)),
3196 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3197 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3198 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3265 mkexpr(arg_n),
3270 mkexpr(arg_m),
3281 mkexpr(arg_n),
3284 mkexpr(arg_m),
3286 mkexpr(cc)));
3293 mkexpr(arg_n),
3296 mkexpr(arg_m),
3303 mkexpr(arg_n),
3306 mkexpr(arg_m),
3308 mkexpr(cc)));
3320 assign(res, binop(Iop_AndV128, mkexpr(arg_n),
3321 mkexpr(arg_m)));
3323 assign(res, binop(Iop_And64, mkexpr(arg_n),
3324 mkexpr(arg_m)));
3334 assign(res, binop(Iop_AndV128,mkexpr(arg_n),
3335 unop(Iop_NotV128, mkexpr(arg_m))));
3337 assign(res, binop(Iop_And64, mkexpr(arg_n),
3338 unop(Iop_Not64, mkexpr(arg_m))));
3349 assign(res, binop(Iop_OrV128, mkexpr(arg_n),
3350 mkexpr(arg_m)));
3352 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3353 mkexpr(arg_m)));
3360 assign(res, mkexpr(arg_m));
3368 assign(res, binop(Iop_OrV128,mkexpr(arg_n),
3369 unop(Iop_NotV128, mkexpr(arg_m))));
3371 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3372 unop(Iop_Not64, mkexpr(arg_m))));
3384 assign(res, binop(Iop_XorV128, mkexpr(arg_n),
3385 mkexpr(arg_m)));
3387 assign(res, binop(Iop_Xor64, mkexpr(arg_n),
3388 mkexpr(arg_m)));
3400 binop(Iop_AndV128, mkexpr(arg_n),
3401 mkexpr(reg_d)),
3403 mkexpr(arg_m),
3405 mkexpr(reg_d)) ) ) );
3411 binop(Iop_And64, mkexpr(arg_n),
3412 mkexpr(reg_d)),
3414 mkexpr(arg_m),
3415 unop(Iop_Not64, mkexpr(reg_d)))));
3428 binop(Iop_AndV128, mkexpr(arg_n),
3429 mkexpr(arg_m)),
3431 mkexpr(reg_d),
3432 unop(Iop_NotV128, mkexpr(arg_m)))));
3438 binop(Iop_And64, mkexpr(arg_n),
3439 mkexpr(arg_m)),
3441 mkexpr(reg_d),
3442 unop(Iop_Not64, mkexpr(arg_m)))));
3455 binop(Iop_AndV128, mkexpr(reg_d),
3456 mkexpr(arg_m)),
3458 mkexpr(arg_n),
3459 unop(Iop_NotV128, mkexpr(arg_m)))));
3465 binop(Iop_And64, mkexpr(reg_d),
3466 mkexpr(arg_m)),
3468 mkexpr(arg_n),
3469 unop(Iop_Not64, mkexpr(arg_m)))));
3544 binop(shOp, mkexpr(arg_n), mkU8(1)),
3545 binop(shOp, mkexpr(arg_m), mkU8(1))),
3548 unop(notOp, mkexpr(arg_n)),
3549 mkexpr(arg_m)),
3606 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3607 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3608 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3636 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3649 binop(op, mkexpr(arg_m), mkexpr(arg_n))));
3695 assign(res, binop(op, mkexpr(arg_m),
3696 unop(Iop_64to8, mkexpr(arg_n))));
3698 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3703 mkexpr(arg_n)));
3705 assign(tmp, binop(sub_op, mkU64(0), mkexpr(arg_n)));
3707 assign(res, binop(op, mkexpr(arg_m),
3708 unop(Iop_64to8, mkexpr(tmp))));
3710 assign(res, binop(op, mkexpr(arg_m), mkexpr(tmp)));
3792 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3797 mkexpr(arg_n),
3804 mkexpr(old_shval),
3806 mkexpr(old_shval),
3816 binop(cmp_gt, mkexpr(shval),
3818 unop(cmp_neq, mkexpr(arg_m))),
3824 assign(mask, binop(cmp_gt, mkexpr(shval),
3827 assign(tmp, binop(op_rev, mkexpr(res),
3828 unop(Iop_64to8, mkexpr(arg_n))));
3830 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
3832 mkexpr(tmp), mkexpr(mask)),
3834 mkexpr(arg_m), mkexpr(mask)),
3929 mkexpr(arg_n),
3936 mkexpr(old_shval),
3938 mkexpr(old_shval),
3945 mkexpr(arg_m),
3948 mkexpr(arg_n),
3949 mkexpr(imm_val)))),
3951 mkexpr(imm_val),
3954 mkexpr(arg_n)))));
3957 mkexpr(arg_m),
3958 unop(Iop_64to8, mkexpr(arg_n))),
3959 mkexpr(round)));
3963 mkexpr(arg_m),
3965 mkexpr(arg_n),
3966 mkexpr(imm_val))),
3968 mkexpr(imm_val),
3971 mkexpr(arg_n)))));
3973 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
3974 mkexpr(round)));
4079 mkexpr(arg_n),
4086 mkexpr(old_shval),
4088 mkexpr(old_shval),
4094 mkexpr(arg_m),
4096 mkexpr(arg_n),
4097 mkexpr(imm_val))),
4099 mkexpr(imm_val),
4102 mkexpr(arg_n)))));
4104 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4105 mkexpr(round)));
4113 binop(cmp_gt, mkexpr(shval),
4115 unop(cmp_neq, mkexpr(arg_m))),
4121 assign(mask, binop(cmp_gt, mkexpr(shval),
4124 assign(tmp, binop(op_rev, mkexpr(res),
4125 unop(Iop_64to8, mkexpr(arg_n))));
4127 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
4129 mkexpr(tmp), mkexpr(mask)),
4131 mkexpr(arg_m), mkexpr(mask)),
4161 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4186 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4245 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4248 binop(op_sub, mkexpr(arg_n),
4249 mkexpr(arg_m)),
4250 mkexpr(cond)),
4252 binop(op_sub, mkexpr(arg_m),
4253 mkexpr(arg_n)),
4255 mkexpr(cond)))));
4323 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4326 binop(op_sub, mkexpr(arg_n),
4327 mkexpr(arg_m)),
4328 mkexpr(cond)),
4330 binop(op_sub, mkexpr(arg_m),
4331 mkexpr(arg_n)),
4333 mkexpr(cond)))));
4334 assign(res, binop(op_add, mkexpr(acc), mkexpr(tmp)));
4369 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4382 mkexpr(arg_n),
4383 mkexpr(arg_m))));
4392 mkexpr(arg_n),
4393 mkexpr(arg_m)))));
4446 binop(op, mkexpr(arg_n), mkexpr(arg_m))));
4472 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4502 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4534 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4536 binop(op2, mkexpr(arg_n),
4538 binop(op2, mkexpr(arg_m),
4568 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4570 binop(op2, mkexpr(arg_n),
4572 binop(op2, mkexpr(arg_m),
4593 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4631 mkexpr(arg_n),
4632 mkexpr(arg_m))));
4636 mkexpr(arg_n),
4637 mkexpr(arg_m))));
4645 assign(res, binop_w_fake_RM(op, mkexpr(arg_n), mkexpr(arg_m)));
4673 binop_w_fake_RM(op, mkexpr(arg_n),
4674 mkexpr(arg_m))));
4685 assign(res, binop_w_fake_RM(op, mkexpr(arg_n), mkexpr(arg_m)));
4701 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4715 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4725 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4740 unop(op2, mkexpr(arg_n)),
4741 unop(op2, mkexpr(arg_m))));
4745 unop(op2, mkexpr(arg_n)),
4746 unop(op2, mkexpr(arg_m))));
4770 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4785 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4795 mkexpr(arg_n),
4796 mkexpr(arg_m)));
4805 mkexpr(arg_n),
4806 mkexpr(arg_m)));
4816 putQReg(dreg, mkexpr(res), condT);
4818 putDRegI64(dreg, mkexpr(res), condT);
4875 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
4922 assign(res, binop(op, mkexpr(tmp),
4925 assign(res, mkexpr(tmp));
4927 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
4978 mkexpr(arg_n), mkexpr(arg_m)),
4979 mkexpr(cond)),
4981 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4982 unop(Iop_NotV128, mkexpr(cond)))),
4984 putQReg(dreg, mkexpr(res), condT);
5032 assign(res, binop(op2, mkexpr(tmp),
5035 assign(res, mkexpr(tmp));
5037 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
5084 binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5085 mkexpr(cond)),
5087 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
5088 unop(Iop_NotV128, mkexpr(cond)))));
5089 putQReg(dreg, mkexpr(res), condT);
5120 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5159 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5160 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5167 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5351 assign(res, binop_w_fake_RM(op, mkexpr(arg_n), mkexpr(arg_m)));
5353 putQReg(dreg, binop_w_fake_RM(op2, getQReg(dreg), mkexpr(res)),
5356 putDRegI64(dreg, binop(op2, getDRegI64(dreg), mkexpr(res)),
5413 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5414 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5480 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5481 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5483 binop(cmp, mkexpr(arg_n), mkU64(imm)),
5484 binop(cmp, mkexpr(arg_m), mkU64(imm))),
5487 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5489 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5581 assign(res, binop_w_fake_RM(op, mkexpr(arg_n), mkexpr(arg_m)));
5583 putQReg(dreg, mkexpr(res), condT);
5585 putDRegI64(dreg, mkexpr(res), condT);
5629 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5630 putQReg(dreg, mkexpr(res), condT);
5687 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5690 binop(op2, mkexpr(arg_n), mkU64(imm)),
5691 binop(op2, mkexpr(arg_m), mkU64(imm))),
5779 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5781 binop(op2, mkexpr(arg_n),
5783 binop(op2, mkexpr(arg_m),
5788 putQReg(dreg, mkexpr(res), condT);
5790 putDRegI64(dreg, mkexpr(res), condT);
5877 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5879 binop(op2, mkexpr(arg_n),
5881 binop(op2, mkexpr(arg_m),
5886 putQReg(dreg, mkexpr(res), condT);
5888 putDRegI64(dreg, mkexpr(res), condT);
6015 mkexpr(reg_m),
6019 mkexpr(reg_m),
6033 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6036 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6044 putQReg(dreg, mkexpr(res), condT);
6046 putDRegI64(dreg, mkexpr(res), condT);
6107 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6110 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6113 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6120 putQReg(dreg, mkexpr(res), condT);
6122 putDRegI64(dreg, mkexpr(res), condT);
6155 mkexpr(mask))),
6159 putQReg(dreg, mkexpr(res), condT);
6167 mkexpr(mask))),
6171 putDRegI64(dreg, mkexpr(res), condT);
6204 mkexpr(mask))),
6208 putQReg(dreg, mkexpr(res), condT);
6216 mkexpr(mask))),
6220 putDRegI64(dreg, mkexpr(res), condT);
6244 putQReg(dreg, mkexpr(res), condT);
6246 putDRegI64(dreg, mkexpr(res), condT);
6346 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6347 assign(tmp, binop(op_rev, mkexpr(res), mkU8(shift_imm)));
6348 setFlag_QC(mkexpr(tmp), mkexpr(reg_m), Q, condT);
6350 putQReg(dreg, mkexpr(res), condT);
6352 putDRegI64(dreg, mkexpr(res), condT);
6388 mkexpr(reg_m),
6390 putDRegI64(dreg, mkexpr(res), condT);
6432 mkexpr(reg_m),
6436 mkexpr(reg_m),
6439 putDRegI64(dreg, mkexpr(res), condT);
6528 binop(op, mkexpr(reg_m), mkU8(shift_imm)),
6531 mkexpr(reg_m),
6536 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6538 setFlag_QC(unop(cvt2, unop(cvt, mkexpr(res))), mkexpr(res),
6540 putDRegI64(dreg, unop(cvt, mkexpr(res)), condT);
6571 putQReg(dreg, mkexpr(res), condT);
6664 assign(res, unop(op, mkexpr(arg_m)));
6685 assign(res, unop(op, mkexpr(arg_m)));
6704 assign(res, unop(op, mkexpr(arg_m)));
6733 assign(res, unop(op, mkexpr(arg_m)));
6751 assign(res, unop(op, mkexpr(arg_m)));
6766 assign(res, unop(op, mkexpr(arg_m)));
6773 assign(res, unop(Q ? Iop_Cnt8x16 : Iop_Cnt8x8, mkexpr(arg_m)));
6780 assign(res, unop(Iop_NotV128, mkexpr(arg_m)));
6782 assign(res, unop(Iop_Not64, mkexpr(arg_m)));
6837 assign(res, binop(add_op, unop(op, mkexpr(arg_m)),
6838 mkexpr(arg_d)));
6881 assign(mask, binop(op_cmp, mkexpr(arg_m), zero1));
6882 neg = binop(op_qsub, zero2, mkexpr(arg_m));
6883 neg2 = binop(op_sub, zero2, mkexpr(arg_m));
6886 mkexpr(mask),
6887 mkexpr(arg_m)),
6890 mkexpr(mask)),
6894 mkexpr(mask),
6895 mkexpr(arg_m)),
6898 mkexpr(mask)),
6900 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
6932 assign(res, binop(op, zero, mkexpr(arg_m)));
6933 setFlag_QC(mkexpr(res), binop(op2, zero, mkexpr(arg_m)),
6943 putQReg(dreg, mkexpr(res), condT);
6945 putDRegI64(dreg, mkexpr(res), condT);
6983 assign(res, binop(op, mkexpr(arg_m), zero));
7003 assign(res, binop(op, mkexpr(arg_m), zero));
7013 binop(op, zero, mkexpr(arg_m))));
7034 assign(res, binop(op, zero, mkexpr(arg_m)));
7044 unop(op, mkexpr(arg_m))));
7065 assign(res, binop(op, zero, mkexpr(arg_m)));
7075 binop(op, mkexpr(arg_m), zero)));
7096 assign(res, binop(op, zero, mkexpr(arg_m)));
7105 assign(res, binop(op, zero, mkexpr(arg_m)));
7124 assign(res, unop(op, mkexpr(arg_m)));
7127 mkexpr(arg_m)));
7144 assign(res, unop(op, mkexpr(arg_m)));
7158 assign(res, binop(op, zero, mkexpr(arg_m)));
7169 putQReg(dreg, mkexpr(res), condT);
7171 putDRegI64(dreg, mkexpr(res), condT);
7181 putQReg(dreg, mkexpr(arg_m), condT);
7186 putDRegI64(dreg, mkexpr(arg_m), condT);
7249 assign(new_d, binop(op_even, mkexpr(old_m), mkexpr(old_d)));
7250 assign(new_m, binop(op_odd, mkexpr(old_m), mkexpr(old_d)));
7252 putQReg(dreg, mkexpr(new_d), condT);
7253 putQReg(mreg, mkexpr(new_m), condT);
7255 putDRegI64(dreg, mkexpr(new_d), condT);
7256 putDRegI64(mreg, mkexpr(new_m), condT);
7300 assign(new_d, binop(op_even, mkexpr(old_m), mkexpr(old_d)));
7301 assign(new_m, binop(op_odd, mkexpr(old_m), mkexpr(old_d)));
7303 putQReg(dreg, mkexpr(new_d), condT);
7304 putQReg(mreg, mkexpr(new_m), condT);
7306 putDRegI64(dreg, mkexpr(new_d), condT);
7307 putDRegI64(mreg, mkexpr(new_m), condT);
7351 assign(new_d, binop(op_lo, mkexpr(old_m), mkexpr(old_d)));
7352 assign(new_m, binop(op_hi, mkexpr(old_m), mkexpr(old_d)));
7354 putQReg(dreg, mkexpr(new_d), condT);
7355 putQReg(mreg, mkexpr(new_m), condT);
7357 putDRegI64(dreg, mkexpr(new_d), condT);
7358 putDRegI64(mreg, mkexpr(new_m), condT);
7433 setFlag_QC(mkexpr(res), mkexpr(tmp), False, condT);
7434 putDRegI64(dreg, mkexpr(res), condT);
7456 putQReg(dreg, mkexpr(res), condT);
7753 expr = binop(Iop_OrV128, mkexpr(tmp_var), imm_val);
7755 expr = binop(Iop_Or64, mkexpr(tmp_var), imm_val);
7760 expr = binop(Iop_AndV128, mkexpr(tmp_var),
7763 expr = binop(Iop_And64, mkexpr(tmp_var), unop(Iop_Not64, imm_val));
7838 loadLE(Ity_I8, mkexpr(addr))), IRTemp_INVALID);
7842 loadLE(Ity_I16, mkexpr(addr))), IRTemp_INVALID);
7846 loadLE(Ity_I32, mkexpr(addr))), IRTemp_INVALID);
7859 mkexpr(addr),
7869 mkexpr(addr),
7879 mkexpr(addr),
7898 storeLE(mkexpr(addr),
7902 storeLE(mkexpr(addr),
7906 storeLE(mkexpr(addr),
7915 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 1)),
7920 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 2)),
7925 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 4)),
7950 assign(*u0, binop(Iop_InterleaveLO32x2, mkexpr(i1), mkexpr(i0)));
7951 assign(*u1, binop(Iop_InterleaveHI32x2, mkexpr(i1), mkexpr(i0)));
7956 assign(*u0, binop(Iop_CatEvenLanes16x4, mkexpr(i1), mkexpr(i0)));
7957 assign(*u1, binop(Iop_CatOddLanes16x4, mkexpr(i1), mkexpr(i0)));
7962 assign(*u0, binop(Iop_CatEvenLanes8x8, mkexpr(i1), mkexpr(i0)));
7963 assign(*u1, binop(Iop_CatOddLanes8x8, mkexpr(i1), mkexpr(i0)));
7986 assign(*i0, binop(Iop_InterleaveLO32x2, mkexpr(u1), mkexpr(u0)));
7987 assign(*i1, binop(Iop_InterleaveHI32x2, mkexpr(u1), mkexpr(u0)));
7992 assign(*i0, binop(Iop_InterleaveLO16x4, mkexpr(u1), mkexpr(u0)));
7993 assign(*i1, binop(Iop_InterleaveHI16x4, mkexpr(u1), mkexpr(u0)));
7998 assign(*i0, binop(Iop_InterleaveLO8x8, mkexpr(u1), mkexpr(u0)));
7999 assign(*i1, binop(Iop_InterleaveHI8x8, mkexpr(u1), mkexpr(u0)));
8027 # define SRC_VEC(_lane) mkexpr(srcs[desc[2 * (7-(_lane)) + 0]])
8048 assign(w1, binop(Iop_InterleaveHI16x4, mkexpr(h3), mkexpr(h2)));
8049 assign(w0, binop(Iop_InterleaveHI16x4, mkexpr(h1), mkexpr(h0)));
8050 return binop(Iop_InterleaveHI32x2, mkexpr(w1), mkexpr(w0));
8062 # define SHL64(_tmp, _amt) binop(Iop_Shl64, mkexpr(_tmp), mkU8(_amt))
8117 # define SHL64(_tmp, _amt) binop(Iop_Shl64, mkexpr(_tmp), mkU8(_amt))
8172 mkexpr(_t1), mkexpr(_t2))
8174 binop(Iop_InterleaveLO32x2, mkexpr(_t1), mkexpr(_t2))
8176 binop(Iop_InterleaveHI16x4, mkexpr(_t1), mkexpr(_t2))
8178 binop(Iop_InterleaveLO16x4, mkexpr(_t1), mkexpr(_t2))
8180 binop(Iop_InterleaveHI8x8, mkexpr(_t1), _e2)
8182 binop(Iop_Shl64, mkexpr(_tmp), mkU8(_amt))
8252 binop(Iop_InterleaveHI32x2, mkexpr(_t1), mkexpr(_t2))
8254 binop(Iop_InterleaveLO32x2, mkexpr(_t1), mkexpr(_t2))
8256 binop(Iop_CatEvenLanes16x4, mkexpr(_t1), mkexpr(_t2))
8258 binop(Iop_CatOddLanes16x4, mkexpr(_t1), mkexpr(_t2))
8260 binop(Iop_CatOddLanes8x8, mkexpr(_t1), _e2)
8262 binop(Iop_Shl64, mkexpr(_tmp), mkU8(_amt))
8379 assign(addr, mkexpr(initialRn));
8429 assign(addr, mkexpr(initialRn));
8438 loadLE(Ity_I8, mkexpr(addr))),
8443 loadLE(Ity_I16, mkexpr(addr))),
8448 loadLE(Ity_I32, mkexpr(addr))),
8460 mkexpr(addr),
8468 mkexpr(addr),
8476 mkexpr(addr),
8504 mkexpr(initialRn),
8512 mkexpr(initialRn),
8513 mkexpr(initialRm));
8579 assign(addr, mkexpr(initialRn));
8587 putDRegI64(rD+r, loadLE(Ity_I64, mkexpr(addr)), IRTemp_INVALID);
8589 storeLE(mkexpr(addr), getDRegI64(rD+r));
8591 assign(tmp, binop(Iop_Add32, mkexpr(addr), mkU32(8)));
8619 IRExpr* a0 = binop(Iop_Add32, mkexpr(addr), mkU32(0));
8620 IRExpr* a1 = binop(Iop_Add32, mkexpr(addr), mkU32(8));
8629 putDRegI64(rD + 0 * regstep, mkexpr(du0), IRTemp_INVALID);
8630 putDRegI64(rD + 1 * regstep, mkexpr(du1), IRTemp_INVALID);
8635 storeLE(a0, mkexpr(di0));
8636 storeLE(a1, mkexpr(di1));
8639 assign(tmp, binop(Iop_Add32, mkexpr(addr), mkU32(16)));
8644 IRExpr* a0 = binop(Iop_Add32, mkexpr(addr), mkU32(0));
8645 IRExpr* a1 = binop(Iop_Add32, mkexpr(addr), mkU32(8));
8646 IRExpr* a2 = binop(Iop_Add32, mkexpr(addr), mkU32(16));
8647 IRExpr* a3 = binop(Iop_Add32, mkexpr(addr), mkU32(24));
8664 putDRegI64(rD + 0 * regstep, mkexpr(du0), IRTemp_INVALID);
8665 putDRegI64(rD + 1 * regstep, mkexpr(du1), IRTemp_INVALID);
8666 putDRegI64(rD + 2 * regstep, mkexpr(du2), IRTemp_INVALID);
8667 putDRegI64(rD + 3 * regstep, mkexpr(du3), IRTemp_INVALID);
8676 storeLE(a0, mkexpr(di0));
8677 storeLE(a1, mkexpr(di1));
8678 storeLE(a2, mkexpr(di2));
8679 storeLE(a3, mkexpr(di3));
8683 assign(tmp, binop(Iop_Add32, mkexpr(addr), mkU32(32)));
8692 IRExpr* a0 = binop(Iop_Add32, mkexpr(addr), mkU32(0));
8693 IRExpr* a1 = binop(Iop_Add32, mkexpr(addr), mkU32(8));
8694 IRExpr* a2 = binop(Iop_Add32, mkexpr(addr), mkU32(16));
8706 putDRegI64(rD + 0 * inc, mkexpr(du0), IRTemp_INVALID);
8707 putDRegI64(rD + 1 * inc, mkexpr(du1), IRTemp_INVALID);
8708 putDRegI64(rD + 2 * inc, mkexpr(du2), IRTemp_INVALID);
8714 storeLE(a0, mkexpr(di0));
8715 storeLE(a1, mkexpr(di1));
8716 storeLE(a2, mkexpr(di2));
8719 assign(tmp, binop(Iop_Add32, mkexpr(addr), mkU32(24)));
8727 IRExpr* a0 = binop(Iop_Add32, mkexpr(addr), mkU32(0));
8728 IRExpr* a1 = binop(Iop_Add32, mkexpr(addr), mkU32(8));
8729 IRExpr* a2 = binop(Iop_Add32, mkexpr(addr), mkU32(16));
8730 IRExpr* a3 = binop(Iop_Add32, mkexpr(addr), mkU32(24));
8746 putDRegI64(rD + 0 * inc, mkexpr(du0), IRTemp_INVALID);
8747 putDRegI64(rD + 1 * inc, mkexpr(du1), IRTemp_INVALID);
8748 putDRegI64(rD + 2 * inc, mkexpr(du2), IRTemp_INVALID);
8749 putDRegI64(rD + 3 * inc, mkexpr(du3), IRTemp_INVALID);
8757 storeLE(a0, mkexpr(di0));
8758 storeLE(a1, mkexpr(di1));
8759 storeLE(a2, mkexpr(di2));
8760 storeLE(a3, mkexpr(di3));
8763 assign(tmp, binop(Iop_Add32, mkexpr(addr), mkU32(32)));
8774 e = binop(Iop_Add32, mkexpr(initialRn),
8777 e = binop(Iop_Add32, mkexpr(initialRn),
8778 mkexpr(initialRm));
8988 assign( res, binop(Iop_Mul32, mkexpr(srcN), mkexpr(srcM)) );
8991 putIRegT( regD, mkexpr(res), condT );
8993 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9045 unop(Iop_64HIto32, mkexpr(irt_prod)),
9048 unop(Iop_64to32, mkexpr(irt_prod)),
9107 binop(Iop_And32, mkexpr(irt_regM_shift), mkU32(mask)),
9168 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
9171 putIRegT( regD, mkexpr(irt_result), condT );
9173 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
9226 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
9229 putIRegT( regD, mkexpr(irt_result), condT );
9231 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
9279 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
9281 assign( irt_regN_hi, binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)) );
9284 or_into_QFLAG32( mkexpr(irt_Q_lo), condT );
9287 or_into_QFLAG32( mkexpr(irt_Q_hi), condT );
9291 binop(Iop_And32, mkexpr(irt_res_lo), mkU32(0xFFFF)),
9292 binop(Iop_Shl32, mkexpr(irt_res_hi), mkU8(16)));
9340 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
9342 assign( irt_regN_hi, binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)) );
9345 or_into_QFLAG32( mkexpr(irt_Q_lo), condT );
9348 or_into_QFLAG32( mkexpr(irt_Q_hi), condT );
9351 binop(Iop_Shl32, mkexpr(irt_res_hi), mkU8(16)),
9352 mkexpr(irt_res_lo) );
9399 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
9401 putIRegT( regD, mkexpr(res), condT );
9403 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9405 assign(reso, binop(Iop_HAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
9448 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
9450 putIRegT( regD, mkexpr(res), condT );
9452 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9455 binop(Iop_HAdd16Sx2, mkexpr(rNt), mkexpr(rMt))));
9498 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
9500 putIRegT( regD, mkexpr(res), condT );
9502 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9505 binop(Iop_HSub16Ux2, mkexpr(rNt), mkexpr(rMt))));
9548 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
9550 putIRegT( regD, mkexpr(res), condT );
9552 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9555 binop(Iop_HSub16Sx2, mkexpr(rNt), mkexpr(rMt))));
9598 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
9600 putIRegT( regD, mkexpr(res), condT );
9602 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9604 assign(reso, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9647 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
9649 putIRegT( regD, mkexpr(res), condT );
9651 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9654 binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt))));
9697 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9699 putIRegT( regD, mkexpr(res), condT );
9701 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9704 binop(Iop_HSub8Ux4, mkexpr(rNt), mkexpr(rMt))));
9747 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9749 putIRegT( regD, mkexpr(res), condT );
9751 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9754 binop(Iop_HSub8Sx4, mkexpr(rNt), mkexpr(rMt))));
9796 assign(res_q, binop(Iop_QAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
9798 putIRegT( regD, mkexpr(res_q), condT );
9800 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9841 assign(res_q, binop(Iop_QSub8Sx4, mkexpr(rNt), mkexpr(rMt)));
9843 putIRegT( regD, mkexpr(res_q), condT );
9845 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9886 assign(res_q, binop(Iop_QAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9888 putIRegT( regD, mkexpr(res_q), condT );
9890 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9931 assign(res_q, binop(Iop_QSub8Ux4, mkexpr(rNt), mkexpr(rMt)));
9933 putIRegT( regD, mkexpr(res_q), condT );
9935 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9976 assign(res_q, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9978 putIRegT( regD, mkexpr(res_q), condT );
9980 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10021 assign(res_q, binop(Iop_HAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
10023 putIRegT( regD, mkexpr(res_q), condT );
10025 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10066 assign(res_q, binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
10068 putIRegT( regD, mkexpr(res_q), condT );
10070 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10111 assign(res_q, binop(Iop_QAdd16Sx2, mkexpr(rNt), mkexpr(rMt)));
10113 putIRegT( regD, mkexpr(res_q), condT );
10115 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10156 assign(res_q, binop(Iop_QSub16Sx2, mkexpr(rNt), mkexpr(rMt)));
10158 putIRegT( regD, mkexpr(res_q), condT );
10160 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10208 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
10210 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
10217 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
10219 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) )) );
10223 binop( Iop_Shl32, mkexpr(irt_diff_res),
10225 binop( Iop_And32, mkexpr(irt_sum_res),
10278 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
10280 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
10285 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
10287 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
10293 binop( Iop_Shl32, mkexpr(irt_res_sum), mkU8(16) ),
10294 binop( Iop_And32, mkexpr(irt_res_diff), mkU32(0xFFFF) ) );
10344 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
10346 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
10350 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
10352 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
10357 binop( Iop_Shl32, mkexpr(irt_sum), mkU8(16) ),
10358 binop( Iop_And32, mkexpr(irt_diff), mkU32(0xFFFF) ) );
10361 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
10362 put_GEFLAG32( 0, 31, mkexpr(ge10), condT );
10363 put_GEFLAG32( 1, 31, mkexpr(ge10), condT );
10366 assign(ge32, unop(Iop_Not32, mkexpr(irt_sum)));
10367 put_GEFLAG32( 2, 31, mkexpr(ge32), condT );
10368 put_GEFLAG32( 3, 31, mkexpr(ge32), condT );
10427 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
10430 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
10433 binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)),
10434 binop(Iop_Sar32, mkexpr(irt_regM), mkU8(16))) );
10437 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) );
10511 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
10514 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
10518 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
10519 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
10521 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) ) );
10523 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_sum), mkexpr(irt_regA));
10532 signed_overflow_after_Add32( mkexpr(irt_sum),
10601 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_prod), mkexpr(irt_regA));
10676 assign( irt_res, binop(Iop_Add64, mkexpr(irt_regD), mkexpr(irt_prod)) );
10677 assign( irt_resHi, unop(Iop_64HIto32, mkexpr(irt_res)) );
10678 assign( irt_resLo, unop(Iop_64to32, mkexpr(irt_res)) );
10681 putIRegT( regDHi, mkexpr(irt_resHi), condT );
10682 putIRegT( regDLo, mkexpr(irt_resLo), condT );
10684 putIRegA( regDHi, mkexpr(irt_resHi), condT, Ijk_Boring );
10685 putIRegA( regDLo, mkexpr(irt_resLo), condT, Ijk_Boring );
10743 binop(Iop_Shl32, unop(Iop_64HIto32, mkexpr(irt_prod)), mkU8(16)),
10744 binop(Iop_Shr32, unop(Iop_64to32, mkexpr(irt_prod)), mkU8(16))
10747 IRExpr* ire_result = binop(Iop_Add32, mkexpr(prod32), mkexpr(irt_regA));
10806 = binop(Iop_Or32, mkexpr(irt_ge_flag0),
10807 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag0)));
10809 = binop(Iop_Or32, mkexpr(irt_ge_flag1),
10810 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag1)));
10812 = binop(Iop_Or32, mkexpr(irt_ge_flag2),
10813 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag2)));
10815 = binop(Iop_Or32, mkexpr(irt_ge_flag3),
10816 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag3)));
10895 binop(Iop_Add32, mkexpr(irt_regN), mkexpr(irt_rot)),
10900 binop(Iop_And32, mkexpr(irt_regN), mkU32(0xFFFF0000)),
10901 binop(Iop_And32, mkexpr(irt_rot), mkU32(0xFFFF0000)));
11004 assign(res_q, binop(Iop_QAdd32S, mkexpr(rMt), mkexpr(rNt)));
11006 putIRegT( regD, mkexpr(res_q), condT );
11008 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11012 binop(Iop_Add32, mkexpr(rMt), mkexpr(rNt)), rMt, rNt),
11058 binop(Iop_Add32, mkexpr(rNt), mkexpr(rNt)), rNt, rNt),
11062 assign(rN_d, binop(Iop_QAdd32S, mkexpr(rNt), mkexpr(rNt)));
11063 assign(res_q, binop(Iop_QAdd32S, mkexpr(rMt), mkexpr(rN_d)));
11065 putIRegT( regD, mkexpr(res_q), condT );
11067 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11071 binop(Iop_Add32, mkexpr(rMt), mkexpr(rN_d)), rMt, rN_d),
11114 assign(res_q, binop(Iop_QSub32S, mkexpr(rMt), mkexpr(rNt)));
11116 putIRegT( regD, mkexpr(res_q), condT );
11118 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11122 binop(Iop_Sub32, mkexpr(rMt), mkexpr(rNt)), rMt, rNt),
11168 binop(Iop_Add32, mkexpr(rNt), mkexpr(rNt)), rNt, rNt),
11172 assign(rN_d, binop(Iop_QAdd32S, mkexpr(rNt), mkexpr(rNt)));
11173 assign(res_q, binop(Iop_QSub32S, mkexpr(rMt), mkexpr(rN_d)));
11175 putIRegT( regD, mkexpr(res_q), condT );
11177 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11181 binop(Iop_Sub32, mkexpr(rMt), mkexpr(rN_d)), rMt, rN_d),
11224 assign(res_q, binop(Iop_QSub16Ux2, mkexpr(rNt), mkexpr(rMt)));
11226 putIRegT( regD, mkexpr(res_q), condT );
11228 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11269 assign(res_q, binop(Iop_HAdd16Sx2, mkexpr(rNt), mkexpr(rMt)));
11271 putIRegT( regD, mkexpr(res_q), condT );
11273 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11314 assign(res_q, binop(Iop_HSub8Ux4, mkexpr(rNt), mkexpr(rMt)));
11316 putIRegT( regD, mkexpr(res_q), condT );
11318 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11359 assign(res_q, binop(Iop_HSub16Ux2, mkexpr(rNt), mkexpr(rMt)));
11361 putIRegT( regD, mkexpr(res_q), condT );
11363 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11404 assign(res_q, binop(Iop_QAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
11406 putIRegT( regD, mkexpr(res_q), condT );
11408 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11454 binop( Iop_Shr32, mkexpr(irt_regN), mkU8(16) ),
11456 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
11463 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
11465 binop( Iop_Shr32, mkexpr(irt_regM), mkU8(16) )) );
11469 binop( Iop_Shl32, mkexpr(irt_diff_res),
11471 binop( Iop_And32, mkexpr(irt_sum_res),
11524 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
11526 binop( Iop_Shr32, mkexpr(irt_regM), mkU8(16) ) ) );
11531 binop( Iop_Shr32, mkexpr(irt_regN), mkU8(16) ),
11533 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
11539 binop( Iop_Shl32, mkexpr(irt_res_sum), mkU8(16) ),
11540 binop( Iop_And32, mkexpr(irt_res_diff), mkU32(0xFFFF) ) );
11590 unop( Iop_32to16, mkexpr(irt_regN) )
11592 binop( Iop_Shr32, mkexpr(irt_regM), mkU8(16) ) ) );
11596 binop( Iop_Shr32, mkexpr(irt_regN), mkU8(16) ),
11598 unop( Iop_32to16, mkexpr(irt_regM) )
11605 binop( Iop_Shl32, mkexpr(irt_diff), mkU8(16) ),
11606 binop( Iop_And32, mkexpr(irt_sum), mkU32(0xFFFF) ) );
11610 mkU32(0x10000), mkexpr(irt_sum) ),
11612 put_GEFLAG32( 0, 0, mkexpr(ge10), condT );
11613 put_GEFLAG32( 1, 0, mkexpr(ge10), condT );
11616 assign(ge32, unop(Iop_Not32, mkexpr(irt_diff)));
11617 put_GEFLAG32( 2, 31, mkexpr(ge32), condT );
11618 put_GEFLAG32( 3, 31, mkexpr(ge32), condT );
11668 unop( Iop_32to16, mkexpr(irt_regN) )
11670 binop( Iop_Shr32, mkexpr(irt_regM), mkU8(16) ) ) );
11674 binop( Iop_Shr32, mkexpr(irt_regN), mkU8(16) ),
11676 unop( Iop_32to16, mkexpr(irt_regM) )
11681 binop( Iop_Shl32, mkexpr(irt_sum), mkU8(16) ),
11682 binop( Iop_And32, mkexpr(irt_diff), mkU32(0xFFFF) ) );
11685 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
11686 put_GEFLAG32( 0, 31, mkexpr(ge10), condT );
11687 put_GEFLAG32( 1, 31, mkexpr(ge10), condT );
11691 mkU32(0x10000), mkexpr(irt_sum) ),
11693 put_GEFLAG32( 2, 0, mkexpr(ge32), condT );
11694 put_GEFLAG32( 3, 0, mkexpr(ge32), condT );
11744 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
11746 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
11750 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
11752 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
11757 binop( Iop_Shl32, mkexpr(irt_diff), mkU8(16) ),
11758 binop( Iop_And32, mkexpr(irt_sum), mkU32(0xFFFF) ) );
11761 assign(ge10, unop(Iop_Not32, mkexpr(irt_sum)));
11762 put_GEFLAG32( 0, 31, mkexpr(ge10), condT );
11763 put_GEFLAG32( 1, 31, mkexpr(ge10), condT );
11766 assign(ge32, unop(Iop_Not32, mkexpr(irt_diff)));
11767 put_GEFLAG32( 2, 31, mkexpr(ge32), condT );
11768 put_GEFLAG32( 3, 31, mkexpr(ge32), condT );
11814 assign(res_q, binop(Iop_HSub8Sx4, mkexpr(rNt), mkexpr(rMt)));
11816 putIRegT( regD, mkexpr(res_q), condT );
11818 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
11866 mkexpr(irt_regN),
11869 unop(Iop_32to8, mkexpr(irt_rot))))),
11875 mkexpr(irt_regN),
11881 mkexpr(irt_rot),
11940 mkexpr(rNt)
11946 mkexpr(rMt), mkU8(16)
11958 mkexpr(rNt), mkU8(16)
11963 unop(Iop_32to16, mkexpr(rMt)
11974 mkexpr(irt_diff), mkU8(1)
11980 mkexpr(irt_sum), mkU8(1)
11988 putIRegT( regD, mkexpr(res_q), condT );
11990 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
12037 mkexpr(rNt)
12043 mkexpr(rMt), mkU8(16)
12055 mkexpr(rNt), mkU8(16)
12060 unop(Iop_32to16, mkexpr(rMt)
12071 mkexpr(irt_diff), mkU8(1)
12077 mkexpr(irt_sum), mkU8(1)
12085 putIRegT( regD, mkexpr(res_q), condT );
12087 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
12134 mkexpr(rNt)
12140 mkexpr(rMt), mkU8(16)
12152 mkexpr(rNt), mkU8(16)
12157 unop(Iop_32to16, mkexpr(rMt)
12168 mkexpr(irt_sum), mkU8(1)
12174 mkexpr(irt_diff), mkU8(1)
12182 putIRegT( regD, mkexpr(res_q), condT );
12184 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
12231 mkexpr(rNt)
12237 mkexpr(rMt), mkU8(16)
12249 mkexpr(rNt), mkU8(16)
12254 unop(Iop_32to16, mkexpr(rMt)
12265 mkexpr(irt_sum), mkU8(1)
12271 mkexpr(irt_diff), mkU8(1)
12279 putIRegT( regD, mkexpr(res_q), condT );
12281 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
12322 assign(res_q, binop(Iop_HSub16Sx2, mkexpr(rNt), mkexpr(rMt)));
12324 putIRegT( regD, mkexpr(res_q), condT );
12326 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
12377 binop(Iop_32HLto64, mkexpr(irt_rA), mkU32(0)),
12378 binop(Iop_MullS32, mkexpr(irt_rN), mkexpr(irt_rM))),
12441 unop(Iop_32to16, mkexpr(irt_rN))
12444 unop(Iop_32to16, mkexpr(op_2))
12449 binop(Iop_Sar32, mkexpr(irt_rN), mkU8(16)),
12450 binop(Iop_Sar32, mkexpr(op_2), mkU8(16))
12455 mkexpr(pr_1),
12456 mkexpr(pr_2)
12459 mkexpr(irt_rDhi),
12460 mkexpr(irt_rDlo)
12464 assign( resHi, unop(Iop_64HIto32, mkexpr(result)) );
12465 assign( resLo, unop(Iop_64to32, mkexpr(result)) );
12467 putIRegT( rDhi, mkexpr(resHi), condT );
12468 putIRegT( rDlo, mkexpr(resLo), condT );
12470 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
12471 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
12529 unop(Iop_32to16, mkexpr(irt_rN))
12532 unop(Iop_32to16, mkexpr(op_2))
12537 binop(Iop_Sar32, mkexpr(irt_rN), mkU8(16)),
12538 binop(Iop_Sar32, mkexpr(op_2), mkU8(16))
12543 mkexpr(pr_1),
12544 mkexpr(pr_2)
12547 mkexpr(irt_rDhi),
12548 mkexpr(irt_rDlo)
12552 assign( resHi, unop(Iop_64HIto32, mkexpr(result)) );
12553 assign( resLo, unop(Iop_64to32, mkexpr(result)) );
12555 putIRegT( rDhi, mkexpr(resHi), condT );
12556 putIRegT( rDlo, mkexpr(resLo), condT );
12558 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
12559 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
12615 /* assign(anchorT, binop(Iop_And32, mkexpr(oldRnT), mkU32(~3U))); */
12617 assign(anchorT, mkexpr(oldRnT));
12636 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
12737 binop(opADDorSUB, mkexpr(anchorT),
12751 storeLE( binop(opADDorSUB, mkexpr(anchorT), mkU32(xOff[i])),
12752 r == rN ? mkexpr(oldRnT)
12760 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
12907 mkexpr(rnT),
12913 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
12920 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
12922 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
12927 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
12940 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
12942 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
13044 mkexpr(rnT),
13050 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
13057 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
13059 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
13064 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
13077 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
13079 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
13179 IRExpr* hi32 = unop(Iop_64HIto32, mkexpr(i64));
13180 IRExpr* lo32 = unop(Iop_64to32, mkexpr(i64));
13447 putDReg(dD, loadLE(Ity_F64,mkexpr(ea)), IRTemp_INVALID);
13449 storeLE(mkexpr(ea), getDReg(dD));
13612 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
13637 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
13638 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
13640 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
13731 : mkexpr(mk_get_IR_rounding_mode()));
13735 mkexpr(rmode),
13743 binop(Iop_F64toI32U, mkexpr(rmode),
13836 mkexpr(rnT),
13842 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
13849 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
13851 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
13856 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(4*i));
13869 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
13871 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
13952 putFReg(fD, loadLE(Ity_F32,mkexpr(ea)), IRTemp_INVALID);
13954 storeLE(mkexpr(ea), getFReg(fD));
14123 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
14148 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
14149 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
14151 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
14224 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
14228 mkexpr(rmode),
14236 mkexpr(rmode),
14258 : mkexpr(mk_get_IR_rounding_mode()));
14262 binop(Iop_F64toI32S, mkexpr(rmode),
14271 binop(Iop_F64toI32U, mkexpr(rmode),
14304 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
14305 putFReg(fD, binop(Iop_F64toF32, mkexpr(rmode), getDReg(dM)),
14356 mkexpr(src32 ) );
14359 triop(Iop_AddF64, rm, mkexpr(scale),
14360 mkexpr(scale)));
14361 IRExpr* resF32 = binop(Iop_F64toF32, mkexpr(rmode), resF64);
14375 mkexpr(src32 ) );
14378 triop(Iop_AddF64, rm, mkexpr(scale),
14379 mkexpr(scale)));
14392 rm, mkexpr(srcF64),
14393 triop(Iop_AddF64, rm, mkexpr(scale),
14394 mkexpr(scale))));
14399 mkexpr(rmode), mkexpr(scaledF64)));
14401 mkexpr(asI32)), condT);
14414 rm, unop(Iop_F32toF64, mkexpr(srcF32)),
14415 triop(Iop_AddF64, rm, mkexpr(scale),
14416 mkexpr(scale))));
14421 mkexpr(rmode), mkexpr(scaledF64)));
14422 putFReg(d, unop(Iop_ReinterpI32asF32, mkexpr(asI32)), condT);
14827 assign(res, binop(op, mkexpr(shop), mkexpr(rNt)) );
14831 assign(res, binop(op, mkexpr(rNt),
14832 unop(Iop_Not32, mkexpr(shop))) );
14835 assign(res, binop(op, mkexpr(rNt), mkexpr(shop)) );
14846 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
14895 assign( res, isMVN ? unop(Iop_Not32, mkexpr(shop))
14896 : mkexpr(shop) );
14910 putIRegA( rD, mkexpr(res), condT, jk );
14967 mkexpr(rNt), mkexpr(shop)) );
15004 binop(Iop_Add32, mkexpr(rNt), mkexpr(shop)),
15005 mkexpr(oldC) ));
15010 binop(Iop_Sub32, mkexpr(rNt), mkexpr(shop)),
15011 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
15016 binop(Iop_Sub32, mkexpr(shop), mkexpr(rNt)),
15017 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
15025 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
15186 putIRegA( rN, mkexpr(eaT), condT, Ijk_Boring );
15192 storeGuardedLE( mkexpr(taT), mkexpr(rDt), condT );
15195 storeGuardedLE( mkexpr(taT), unop(Iop_32to8, mkexpr(rDt)), condT );
15216 mkexpr(taT), llGetIReg(rD), condT );
15226 putIRegA( rD, mkexpr(tD),
15231 loadGuardedLE( tD, ILGop_8Uto32, mkexpr(taT), llGetIReg(rD), condT );
15234 putIRegA( rD, mkexpr(tD), IRTemp_INVALID, Ijk_Boring );
15243 putIRegA( rN, mkexpr(eaT), condT, Ijk_Boring );
15431 storeGuardedLE( mkexpr(taT),
15438 mkexpr(taT), mkexpr(llOldRd), condT );
15439 putIRegA( rD, mkexpr(newRd), IRTemp_INVALID, Ijk_Boring );
15445 mkexpr(taT), mkexpr(llOldRd), condT );
15446 putIRegA( rD, mkexpr(newRd), IRTemp_INVALID, Ijk_Boring );
15452 mkexpr(taT), mkexpr(llOldRd), condT );
15453 putIRegA( rD, mkexpr(newRd), IRTemp_INVALID, Ijk_Boring );
15465 putIRegA( rN, mkexpr(eaT), condT, Ijk_Boring );
15602 unop(Iop_32to1, mkexpr(condT))),
15621 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
15632 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
15667 llPutIReg(15, mkexpr(dst));
15697 binop(Iop_CmpEQ32, mkexpr(arg), mkU32(0)),
15699 unop(Iop_Clz32, mkexpr(arg))
15701 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
15725 assign( res, binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) );
15733 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
15737 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
15738 mkexpr(oldV)) );
15764 assign(res, binop(Iop_DivS32, mkexpr(argL), mkexpr(argR)));
15765 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
15786 assign(res, binop(Iop_DivU32, mkexpr(argL), mkexpr(argR)));
15787 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
15820 mkexpr(argP),
15821 binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) ));
15830 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
15834 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
15835 mkexpr(oldV)) );
15868 assign( res, binop(mulOp, mkexpr(argL), mkexpr(argR)) );
15869 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
15870 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
15878 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
15879 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
15883 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
15884 mkexpr(oldV)) );
15920 mkexpr(old),
15921 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
15922 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
15923 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
15931 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
15932 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
15936 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
15937 mkexpr(oldV)) );
15971 binop(Iop_MullU32, mkexpr(argN), mkexpr(argM)),
15972 unop(Iop_32Uto64, mkexpr(argDhi))),
15973 unop(Iop_32Uto64, mkexpr(argDlo))) );
15974 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
15975 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
15977 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
15978 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
16031 putIRegA( rD, mkexpr(apsr), condT, Ijk_Boring );
16085 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
16087 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
16088 unop(Iop_32to8, mkexpr(tNew))) );
16092 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
16094 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
16095 mkexpr(tNew)) );
16097 stmt( IRStmt_Exit(unop(Iop_Not1, mkexpr(tSC1)),
16101 putIRegA(rD, isB ? unop(Iop_8Uto32, mkexpr(tOld)) : mkexpr(tOld),
16153 putIRegA(rT+0, unop(Iop_64to32, mkexpr(res)),
16155 putIRegA(rT+1, unop(Iop_64HIto32, mkexpr(res)),
16161 ? mkexpr(res) : unop(widen, mkexpr(res)),
16214 stmt( IRStmt_LLSC(Iend_LE, resSC1, getIRegA(rN), mkexpr(data)) );
16220 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
16222 putIRegA(rD, mkexpr(resSC32),
16282 assign(dstT, unop(Iop_8Uto32, unop(Iop_32to8, mkexpr(rotT))));
16286 assign(dstT, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rotT))));
16290 assign(dstT, unop(Iop_16Uto32, unop(Iop_32to16, mkexpr(rotT))));
16294 assign(dstT, unop(Iop_16Sto32, unop(Iop_32to16, mkexpr(rotT))));
16298 assign(dstT, binop(Iop_And32, mkexpr(rotT), mkU32(0x00FF00FF)));
16304 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
16305 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
16311 unop(Iop_32to8, mkexpr(lo32))),
16315 unop(Iop_32to8, mkexpr(hi32))),
16324 putIRegA(rD, mkexpr(dstT), condT, Ijk_Boring);
16354 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
16357 mkexpr(olddst),
16361 putIRegA(rD, mkexpr(newdst), condT, Ijk_Boring);
16396 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
16399 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
16402 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
16553 putIRegA( rN, mkexpr(eaT), condT, Ijk_Boring );
16563 storeGuardedLE( binop(Iop_Add32, mkexpr(taT), mkU32(0)),
16565 storeGuardedLE( binop(Iop_Add32, mkexpr(taT), mkU32(4)),
16576 binop(Iop_Add32, mkexpr(taT), mkU32(0)),
16577 mkexpr(oldRd0), condT );
16578 putIRegA( rD+0, mkexpr(newRd0), IRTemp_INVALID, Ijk_Boring );
16580 binop(Iop_Add32, mkexpr(taT), mkU32(4)),
16581 mkexpr(oldRd1), condT );
16582 putIRegA( rD+1, mkexpr(newRd1), IRTemp_INVALID, Ijk_Boring );
16596 putIRegA( rN, mkexpr(eaT), condT, Ijk_Boring );
16635 mkexpr(srcL),
16639 mkexpr(res), condT, Ijk_Boring);
16665 mkexpr(srcL),
16669 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
16688 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
16707 binop(Iop_Shl32, mkexpr(irt_rM), mkU8(24)),
16713 binop(Iop_Shr32, mkexpr(irt_rM), mkU8(8)),
16718 binop(Iop_Or32, mkexpr(irt_hi), mkexpr(irt_low))
16720 putIRegA(rD, mkexpr(irt_res), condT, Ijk_Boring);
16734 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
16800 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16830 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16855 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16885 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16914 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16941 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16970 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
16997 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
17026 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
17053 putIRegA(rT, mkexpr(newRt), IRTemp_INVALID, Ijk_Boring);
17311 ? mkU32(1) : mkexpr(condT)),
17422 mkexpr(r15guard), mkU32(1))),
17749 // binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
17767 // binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
17781 // mkexpr(old_itstate),
17783 // mkexpr(condT1),
17797 // binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
17806 // binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
17817 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
17832 binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
17856 we can simply do "assign(condT, mkexpr(condT1))", and the
17862 mkexpr(old_itstate),
17865 mkexpr(condT1),
17876 binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
17885 binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
17972 putIRegT(rD, binop(Iop_Sub32, mkexpr(zero), mkexpr(arg)), condT);
17990 putIRegT(rD, mkexpr(res), condT);
18021 putIRegT(rD, mkexpr(res), condT);
18042 putIRegT(rD, mkexpr(res), condT);
18062 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
18063 mkexpr(oldC)));
18065 putIRegT(rD, mkexpr(res), condT);
18085 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
18086 binop(Iop_Xor32, mkexpr(oldC), mkU32(1))));
18088 putIRegT(rD, mkexpr(res), condT);
18193 putIRegT(rD, mkexpr(res), condT);
18210 putIRegT(rD, mkexpr(res), condT);
18226 binop(Iop_Shl32, mkexpr(irt_rM), mkU8(24)),
18232 binop(Iop_Shr32, mkexpr(irt_rM), mkU8(8)),
18237 binop(Iop_Or32, mkexpr(irt_hi), mkexpr(irt_low))
18239 putIRegT(rD, mkexpr(irt_res), condT);
18290 llPutIReg(15, mkexpr(dst));
18314 llPutIReg(15, mkexpr(dst));
18370 putIRegT( rD, mkexpr(res), condT );
18379 llPutIReg(15, binop(Iop_Or32, mkexpr(res), mkU32(1)));
18420 putIRegT( rD, mkexpr(val), condT );
18429 llPutIReg(15, binop(Iop_Or32, mkexpr(val), mkU32(1)));
18484 stmt(IRStmt_Exit( mkexpr(kond),
18537 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
18542 assign(base, binop(Iop_And32, mkexpr(newSP), mkU32(~3)));
18548 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(4 * nRegs)),
18594 assign(base, binop(Iop_And32, mkexpr(oldSP), mkU32(~3)));
18600 assign(newSP, binop(Iop_Add32, mkexpr(oldSP),
18608 binop(Iop_Add32, mkexpr(base),
18619 binop(Iop_Add32, mkexpr(base),
18624 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
18635 llPutIReg(15, mkexpr(newPC));
18659 mkexpr(argL), mkexpr(argR)),
18680 mkexpr(argL), mkexpr(argR)),
18703 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18728 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18749 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18767 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18789 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18821 mkexpr(argL), mkexpr(argR)), condT );
18876 putIRegT(rD, mkexpr(res), condT);
18895 loadGuardedLE( tD, ILGop_Ident32, mkexpr(ea), llGetIReg(rD), condT );
18896 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18918 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18943 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18968 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
18992 putIRegT(rD, mkexpr(tD), IRTemp_INVALID);
19017 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
19024 binop(Iop_Add32, mkexpr(base),
19033 binop(Iop_Add32, mkexpr(oldRn),
19071 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
19076 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(nRegs * 4 - 4)),
19081 binop(Iop_Add32, mkexpr(oldRn),
19135 putIRegT(rD, mkexpr(res), condT);
19184 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
19215 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
19397 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
19398 putIRegT(rD, mkexpr(res), condT);
19424 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
19425 putIRegT(rD, mkexpr(res), condT);
19473 mkexpr(argL), mkexpr(argR)));
19507 ? binop(Iop_Sub32, mkexpr(argR), mkexpr(argL))
19508 : binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
19509 putIRegT(rD, mkexpr(res), condT);
19539 assign(res, binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
19540 putIRegT(rD, mkexpr(res), condT);
19572 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
19573 mkexpr(oldC) ));
19574 putIRegT(rD, mkexpr(res), condT);
19583 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
19584 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
19585 putIRegT(rD, mkexpr(res), condT);
19634 assign(res, binop(op, mkexpr(argL), mkexpr(argR)));
19635 putIRegT(rD, mkexpr(res), condT);
19705 ? binop(op, mkexpr(argR), mkexpr(argL))
19706 : binop(op, mkexpr(argL), mkexpr(argR)));
19708 putIRegT(rD, mkexpr(res), condT);
19768 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
19769 mkexpr(oldC) ));
19770 putIRegT(rD, mkexpr(res), condT);
19779 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
19780 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
19781 putIRegT(rD, mkexpr(res), condT);
19845 assign(res, binop(op, mkexpr(rNt),
19846 unop(Iop_Not32, mkexpr(argR))));
19848 assign(res, binop(op, mkexpr(rNt), mkexpr(argR)));
19851 putIRegT(rD, mkexpr(res), condT);
19894 putIRegT(rD, mkexpr(res), condT);
19930 assign(res, isMVN ? unop(Iop_Not32, mkexpr(oldRn))
19931 : mkexpr(oldRn));
19933 putIRegT(rD, mkexpr(res), condT);
19977 mkexpr(argL), mkexpr(argR)));
20034 putIRegT(rD, mkexpr(res), condT);
20078 putIRegT(rD, mkexpr(res), condT);
20167 mkexpr(preAddr), mkU32(imm8)));
20190 putIRegT(rN, mkexpr(postAddr), condT);
20197 data = unop(Iop_32to8, mkexpr(oldRt));
20200 data = unop(Iop_32to16, mkexpr(oldRt));
20203 data = mkexpr(oldRt);
20208 storeGuardedLE(mkexpr(transAddr), data, condT);
20230 mkexpr(transAddr), mkexpr(llOldRt), condT);
20239 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
20245 putIRegT(rN, mkexpr(postAddr), condT);
20253 llPutIReg(15, mkexpr(newRt));
20365 data = unop(Iop_32to8, mkexpr(oldRt));
20368 data = unop(Iop_32to16, mkexpr(oldRt));
20371 data = mkexpr(oldRt);
20376 storeGuardedLE(mkexpr(transAddr), data, condT);
20398 mkexpr(transAddr), mkexpr(llOldRt), condT);
20408 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
20416 llPutIReg(15, mkexpr(newRt));
20514 mkexpr(rNt), mkU32(imm12)));
20526 data = unop(Iop_32to8, mkexpr(oldRt));
20529 data = unop(Iop_32to16, mkexpr(oldRt));
20532 data = mkexpr(oldRt);
20537 storeGuardedLE(mkexpr(transAddr), data, condT);
20552 mkexpr(transAddr), mkexpr(llOldRt), condT);
20561 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
20568 llPutIReg(15, mkexpr(newRt));
20614 mkexpr(preAddr), mkU32(imm8 << 2)));
20628 putIRegT(rN, mkexpr(postAddr), condT);
20637 storeGuardedLE( mkexpr(transAddr),
20638 mkexpr(oldRt), condT );
20639 storeGuardedLE( binop(Iop_Add32, mkexpr(transAddr), mkU32(4)),
20640 mkexpr(oldRt2), condT );
20649 mkexpr(transAddr),
20650 mkexpr(oldRt), condT );
20652 binop(Iop_Add32, mkexpr(transAddr), mkU32(4)),
20653 mkexpr(oldRt2), condT );
20656 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
20657 putIRegT(rT2, mkexpr(newRt2), IRTemp_INVALID);
20661 putIRegT(rN, mkexpr(postAddr), condT);
20708 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
20794 binop(Iop_Shl32, mkexpr(delta), mkU8(1))
20830 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
20833 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
20836 putIRegT(rD, mkexpr(res), condT);
20874 unop(Iop_32to8, mkexpr(rotT))));
20879 unop(Iop_32to16, mkexpr(rotT))));
20884 unop(Iop_32to8, mkexpr(rotT))));
20889 unop(Iop_32to16, mkexpr(rotT))));
20893 assign(dstT, binop(Iop_And32, mkexpr(rotT),
20900 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
20901 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
20907 unop(Iop_32to8, mkexpr(lo32))),
20911 unop(Iop_32to8, mkexpr(hi32))),
20919 putIRegT(rD, mkexpr(dstT), condT);
20934 putIRegT(rD, mkexpr(res), condT);
20952 assign(res, binop(Iop_DivS32, mkexpr(argL), mkexpr(argR)));
20953 putIRegT(rD, mkexpr(res), condT);
20971 assign(res, binop(Iop_DivU32, mkexpr(argL), mkexpr(argR)));
20972 putIRegT(rD, mkexpr(res), condT);
20991 putIRegT( rDhi, unop(Iop_64HIto32, mkexpr(res)), condT );
20992 putIRegT( rDlo, unop(Iop_64to32, mkexpr(res)), condT );
21015 putIRegT(rD, mkexpr(res), condT);
21062 mkexpr(old),
21063 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
21064 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
21065 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
21066 putIRegT( rDhi, mkexpr(resHi), condT );
21067 putIRegT( rDlo, mkexpr(resLo), condT );
21096 binop(Iop_MullU32, mkexpr(argN), mkexpr(argM)),
21097 unop(Iop_32Uto64, mkexpr(argDhi))),
21098 unop(Iop_32Uto64, mkexpr(argDlo))) );
21099 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
21100 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
21101 putIRegT( rDhi, mkexpr(resHi), condT );
21102 putIRegT( rDlo, mkexpr(resLo), condT );
21194 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
21197 mkexpr(olddst),
21201 putIRegT(rD, mkexpr(newdst), condT);
21232 mkexpr(srcL),
21236 putIRegT(rD, mkexpr(res), condT);
21261 mkexpr(srcL),
21265 putIRegT(rD, mkexpr(res), condT);
21284 binop(Iop_CmpEQ32, mkexpr(arg), mkU32(0)),
21286 unop(Iop_Clz32, mkexpr(arg))
21288 putIRegT(rD, mkexpr(res), condT);
21305 putIRegT(rD, mkexpr(res), condT);
21325 putIRegT(rD, mkexpr(res), condT);
21346 binop(Iop_Shl32, mkexpr(irt_rM), mkU8(24)),
21352 binop(Iop_Shr32, mkexpr(irt_rM), mkU8(8)),
21357 binop(Iop_Or32, mkexpr(irt_hi), mkexpr(irt_low))
21359 putIRegT(rD, mkexpr(irt_res), condT);
21387 putIRegT( rD, mkexpr(apsr), condT );
21408 putIRegT(rT, mkexpr(res), IRTemp_INVALID);
21428 putIRegT(rT, unop(isH ? Iop_16Uto32 : Iop_8Uto32, mkexpr(res)),
21450 putIRegT(rT, unop(Iop_64to32, mkexpr(res)), IRTemp_INVALID);
21451 putIRegT(rT2, unop(Iop_64HIto32, mkexpr(res)), IRTemp_INVALID);
21479 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
21480 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
21508 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
21509 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
21533 stmt( IRStmt_LLSC(Iend_LE, resSC1, getIRegT(rN), mkexpr(data)));
21538 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
21539 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
21684 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
21756 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
21785 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
21831 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
21855 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
22182 assign(hi32, unop(Iop_64HIto32, mkexpr(v64)) );
22183 assign(lo32, unop(Iop_64to32, mkexpr(v64)) );
22184 if (out3) assign(*out3, binop(Iop_Shr32, mkexpr(hi32), mkU8(16)));
22185 if (out2) assign(*out2, binop(Iop_And32, mkexpr(hi32), mkU32(0xFFFF)));
22186 if (out1) assign(*out1, binop(Iop_Shr32, mkexpr(lo32), mkU8(16)));
22187 if (out0) assign(*out0, binop(Iop_And32, mkexpr(lo32), mkU32(0xFFFF)));
22198 binop(Iop_Shl32, mkexpr(in3), mkU8(16)),
22199 binop(Iop_And32, mkexpr(in2), mkU32(0xFFFF))));
22202 binop(Iop_Shl32, mkexpr(in1), mkU8(16)),
22203 binop(Iop_And32, mkexpr(in0), mkU32(0xFFFF))));
22205 assign(res, binop(Iop_32HLto64, mkexpr(hi32), mkexpr(lo32)));
22215 return mkexpr(mk64from16s(a1, b1, a0, b0));
22224 return mkexpr(mk64from16s(a3, b3, a2, b2));
22233 return mkexpr(mk64from16s(a2, a0, b2, b0));
22242 return mkexpr(mk64from16s(a3, a1, b3, b1));
22251 return mkexpr(mk64from16s(a3, b3, a1, b1));
22260 return mkexpr(mk64from16s(a2, b2, a0, b0));
22277 assign(hi32, unop(Iop_64HIto32, mkexpr(v64)) );
22278 assign(lo32, unop(Iop_64to32, mkexpr(v64)) );
22281 binop(Iop_Shr32, mkexpr(hi32), mkU8(24)),
22285 binop(Iop_Shr32, mkexpr(hi32), mkU8(16)),
22289 binop(Iop_Shr32, mkexpr(hi32), mkU8(8)),
22292 assign(*out4, binop(Iop_And32, mkexpr(hi32), mkU32(0xFF)));
22295 binop(Iop_Shr32, mkexpr(lo32), mkU8(24)),
22299 binop(Iop_Shr32, mkexpr(lo32), mkU8(16)),
22303 binop(Iop_Shr32, mkexpr(lo32), mkU8(8)),
22306 assign(*out0, binop(Iop_And32, mkexpr(lo32), mkU32(0xFF)));
22318 binop(Iop_And32, mkexpr(in7), mkU32(0xFF)),
22321 binop(Iop_And32, mkexpr(in6), mkU32(0xFF)),
22325 binop(Iop_And32, mkexpr(in5), mkU32(0xFF)), mkU8(8)),
22327 mkexpr(in4), mkU32(0xFF)))));
22332 binop(Iop_And32, mkexpr(in3), mkU32(0xFF)),
22335 binop(Iop_And32, mkexpr(in2), mkU32(0xFF)),
22339 binop(Iop_And32, mkexpr(in1), mkU32(0xFF)), mkU8(8)),
22341 mkexpr(in0), mkU32(0xFF)))));
22343 assign(res, binop(Iop_32HLto64, mkexpr(hi32), mkexpr(lo32)));
22353 return mkexpr(mk64from8s(a3, b3, a2, b2, a1, b1, a0, b0));
22362 return mkexpr(mk64from8s(a7, b7, a6, b6, a5, b5, a4, b4));
22371 return mkexpr(mk64from8s(a6, a4, a2, a0, b6, b4, b2, b0));
22380 return mkexpr(mk64from8s(a7, a5, a3, a1, b7, b5, b3, b1));
22389 return mkexpr(mk64from8s(a6, b6, a4, b4, a2, b2, a0, b0));
22398 return mkexpr(mk64from8s(a7, b7, a5, b5, a3, b3, a1, b1));
22404 return binop(Iop_32HLto64, unop(Iop_64to32, mkexpr(a10)),
22405 unop(Iop_64to32, mkexpr(b10)));
22411 return binop(Iop_32HLto64, unop(Iop_64HIto32, mkexpr(a10)),
22412 unop(Iop_64HIto32, mkexpr(b10)));
