Lines Matching refs: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)),
1317 stmt( IRStmt_Put( OFFB_CC_DEP1, mkexpr(t_dep1) ));
1318 stmt( IRStmt_Put( OFFB_CC_DEP2, mkexpr(t_dep2) ));
1319 stmt( IRStmt_Put( OFFB_CC_NDEP, mkexpr(t_ndep) ));
1323 assign( c8, unop(Iop_32to8, mkexpr(guardT)) );
1326 IRExpr_Mux0X( mkexpr(c8),
1331 IRExpr_Mux0X( mkexpr(c8),
1333 mkexpr(t_dep1) )));
1336 IRExpr_Mux0X( mkexpr(c8),
1338 mkexpr(t_dep2) )));
1341 IRExpr_Mux0X( mkexpr(c8),
1343 mkexpr(t_ndep) )));
1399 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1416 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1434 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1452 binop(Iop_CmpNE32, mkexpr(t), mkU32(0)),
1477 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
1508 mkexpr(res1),
1512 mkexpr(get_QFLAG32()),
1528 mkexpr(res2),
1549 assign(immT, binop(Iop_And32, mkexpr(apsrT), mkU32(0xF0000000)) );
1553 assign(qnewT, binop(Iop_And32, mkexpr(apsrT), mkU32(ARMG_CC_MASK_Q)));
1558 put_GEFLAG32(0, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<16)),
1560 put_GEFLAG32(1, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<17)),
1562 put_GEFLAG32(2, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<18)),
1564 put_GEFLAG32(3, 0, binop(Iop_And32, mkexpr(apsrT), mkU32(1<<19)),
1606 assign( node0, mkexpr(regT) );
1608 assign( node2, binop( Iop_CmpLT32S, mkexpr(node1), mkexpr(node0) ) );
1609 assign( node3, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node2)),
1610 mkexpr(node0),
1611 mkexpr(node1) ) );
1613 assign( node5, binop( Iop_CmpLT32S, mkexpr(node3), mkexpr(node4) ) );
1614 assign( node6, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node5)),
1615 mkexpr(node3),
1616 mkexpr(node4) ) );
1617 assign( *res, mkexpr(node6) );
1622 assign( *resQ, binop(Iop_Xor32, mkexpr(*res), mkexpr(regT)) );
1654 assign( node0, mkexpr(regT) );
1656 assign( node2, binop( Iop_CmpLT32S, mkexpr(node1), mkexpr(node0) ) );
1657 assign( node3, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node2)),
1658 mkexpr(node0), mkexpr(node1) ) );
1660 assign( node5, binop( Iop_CmpLT32S, mkexpr(node3), mkexpr(node4) ) );
1661 assign( node6, IRExpr_Mux0X( unop(Iop_1Uto8, mkexpr(node5)),
1662 mkexpr(node3), mkexpr(node4) ) );
1663 assign( *res, mkexpr(node6) );
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)) );
1789 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
1792 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
1796 mkexpr(rMt),
1801 mkexpr(amtT)),
1809 mkexpr(oldC)
1822 mkexpr(rMt),
1824 binop(Iop_And32, mkexpr(rSt), mkU32(31)))),
1827 mkexpr(amtT),
1849 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1862 binop(Iop_Shr32, mkexpr(rMt),
1867 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)) );
1887 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
1901 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
1904 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
1908 mkexpr(rMt),
1912 mkexpr(amtT),
1921 mkexpr(oldC)
1934 mkexpr(rMt),
1936 binop(Iop_And32, mkexpr(rSt), mkU32(31)))),
1939 mkexpr(amtT),
1961 binop(Iop_Shr32, mkexpr(rMt), mkU8(31)),
1964 assign( *res, binop(Iop_Sar32, mkexpr(rMt), mkU8(31)) );
1974 binop(Iop_Shr32, mkexpr(rMt),
1979 binop(Iop_Sar32, mkexpr(rMt), mkU8(shift_amt)) );
1999 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
2013 binop(Iop_CmpEQ32, mkexpr(amtT), mkU32(0))),
2016 binop(Iop_CmpLE32U, mkexpr(amtT), mkU32(32))),
2019 mkexpr(rMt),
2026 mkexpr(rMt),
2030 mkexpr(amtT),
2039 mkexpr(oldC)
2048 mkexpr(rMt),
2054 binop(Iop_CmpLT32U, mkexpr(amtT), mkU32(32))),
2056 mkexpr(amtT)))));
2074 assign( amtT, binop(Iop_And32, mkexpr(rSt), mkU32(255)) );
2076 assign( amt5T, binop(Iop_And32, mkexpr(rSt), mkU32(31)) );
2083 unop(Iop_32to8, mkexpr(amtT)),
2084 mkexpr(oldC),
2087 mkexpr(rMt),
2091 mkexpr(amtT),
2106 unop(Iop_32to8, mkexpr(amt5T)), mkexpr(rMt),
2109 mkexpr(rMt),
2110 unop(Iop_32to8, mkexpr(amt5T))
2113 mkexpr(rMt),
2115 binop(Iop_Sub32, mkU32(32), mkexpr(amt5T))
2182 binop(Iop_And32, mkexpr(rMt), mkU32(1)));
2187 binop(Iop_Shl32, mkexpr(oldcT), mkU8(31)),
2188 binop(Iop_Shr32, mkexpr(rMt), mkU8(1))) );
2198 binop(Iop_Shr32, mkexpr(rMt),
2204 binop(Iop_Shr32, mkexpr(rMt), mkU8(shift_amt)),
2205 binop(Iop_Shl32, mkexpr(rMt),
2441 binop(Iop_Shl32, mkexpr(cflagT), mkU8(31)),
2442 binop(Iop_Shr32, mkexpr(rmT), mkU8(1)));
2449 binop(Iop_Shl32, mkexpr(rmT), mkU8(32-imm5)),
2450 binop(Iop_Shr32, mkexpr(rmT), mkU8(imm5)));
2542 binop(Iop_Shr32, mkexpr(irRes), mkU8(5)),
2544 binop(Iop_And32, mkexpr(irRes), mkU32(1))));
2552 binop(Iop_Xor32, mkexpr(ix), mkU32(1)),
2562 mkexpr(ix),
2563 binop(Iop_Shr32, mkexpr(ix), mkU8(1))),
2566 assign(nzcv, binop(Iop_Sub32, mkexpr(termL), mkexpr(termR)));
2723 binop(Iop_And32, mkexpr(x0), mkU32(c1)),
2726 binop(Iop_And32, mkexpr(x0), mkU32(~c1)),
2732 binop(Iop_And32, mkexpr(x1), mkU32(c2)),
2735 binop(Iop_And32, mkexpr(x1), mkU32(~c2)),
2741 binop(Iop_And32, mkexpr(x2), mkU32(c3)),
2744 binop(Iop_And32, mkexpr(x2), mkU32(~c3)),
2750 binop(Iop_And32, mkexpr(x3), mkU32(c4)),
2753 binop(Iop_And32, mkexpr(x3), mkU32(~c4)),
2759 binop(Iop_And32, mkexpr(x4), mkU32(c5)),
2762 binop(Iop_And32, mkexpr(x4), mkU32(~c5)),
2776 binop(Iop_Shl32, mkexpr(arg), mkU8(24)),
2778 binop(Iop_And32, binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2781 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2783 binop(Iop_And32, binop(Iop_Shr32, mkexpr(arg), mkU8(24)),
2798 binop(Iop_Shl32, mkexpr(arg), mkU8(8)),
2801 binop(Iop_Shr32, mkexpr(arg), mkU8(8)),
2927 assign(new_arg, binop(Iop_Sub8x8, mkexpr(old_arg), mkU64(imm)));
2928 assign(cur_mask, binop(cmp, mkU64(imm), mkexpr(old_arg)));
2929 assign(new_mask, binop(Iop_Or64, mkexpr(old_mask), mkexpr(cur_mask)));
2931 mkexpr(old_res),
2934 mkexpr(arg_l),
2936 mkexpr(old_arg),
2937 mkexpr(cur_mask))),
2938 mkexpr(cur_mask))));
2949 unop(Iop_Not64, mkexpr(old_mask))),
2950 mkexpr(old_res)));
2954 putDRegI64(dreg, mkexpr(old_res), condT);
3009 assign(res, unop(op, binop(op2, mkexpr(arg_m), mkU8(index))));
3011 putQReg(dreg, mkexpr(res), condT);
3013 putDRegI64(dreg, mkexpr(res), condT);
3115 binop(shOp, mkexpr(arg_m), mkU8(1)),
3116 binop(shOp, mkexpr(arg_n), mkU8(1))),
3119 binop(andOp, mkexpr(arg_m), imm_val),
3120 binop(andOp, mkexpr(arg_n), imm_val)),
3178 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3180 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3181 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3249 mkexpr(arg_n),
3254 mkexpr(arg_m),
3265 mkexpr(arg_n),
3268 mkexpr(arg_m),
3270 mkexpr(cc)));
3277 mkexpr(arg_n),
3280 mkexpr(arg_m),
3287 mkexpr(arg_n),
3290 mkexpr(arg_m),
3292 mkexpr(cc)));
3304 assign(res, binop(Iop_AndV128, mkexpr(arg_n),
3305 mkexpr(arg_m)));
3307 assign(res, binop(Iop_And64, mkexpr(arg_n),
3308 mkexpr(arg_m)));
3318 assign(res, binop(Iop_AndV128,mkexpr(arg_n),
3319 unop(Iop_NotV128, mkexpr(arg_m))));
3321 assign(res, binop(Iop_And64, mkexpr(arg_n),
3322 unop(Iop_Not64, mkexpr(arg_m))));
3333 assign(res, binop(Iop_OrV128, mkexpr(arg_n),
3334 mkexpr(arg_m)));
3336 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3337 mkexpr(arg_m)));
3344 assign(res, mkexpr(arg_m));
3352 assign(res, binop(Iop_OrV128,mkexpr(arg_n),
3353 unop(Iop_NotV128, mkexpr(arg_m))));
3355 assign(res, binop(Iop_Or64, mkexpr(arg_n),
3356 unop(Iop_Not64, mkexpr(arg_m))));
3368 assign(res, binop(Iop_XorV128, mkexpr(arg_n),
3369 mkexpr(arg_m)));
3371 assign(res, binop(Iop_Xor64, mkexpr(arg_n),
3372 mkexpr(arg_m)));
3384 binop(Iop_AndV128, mkexpr(arg_n),
3385 mkexpr(reg_d)),
3387 mkexpr(arg_m),
3389 mkexpr(reg_d)) ) ) );
3395 binop(Iop_And64, mkexpr(arg_n),
3396 mkexpr(reg_d)),
3398 mkexpr(arg_m),
3399 unop(Iop_Not64, mkexpr(reg_d)))));
3412 binop(Iop_AndV128, mkexpr(arg_n),
3413 mkexpr(arg_m)),
3415 mkexpr(reg_d),
3416 unop(Iop_NotV128, mkexpr(arg_m)))));
3422 binop(Iop_And64, mkexpr(arg_n),
3423 mkexpr(arg_m)),
3425 mkexpr(reg_d),
3426 unop(Iop_Not64, mkexpr(arg_m)))));
3439 binop(Iop_AndV128, mkexpr(reg_d),
3440 mkexpr(arg_m)),
3442 mkexpr(arg_n),
3443 unop(Iop_NotV128, mkexpr(arg_m)))));
3449 binop(Iop_And64, mkexpr(reg_d),
3450 mkexpr(arg_m)),
3452 mkexpr(arg_n),
3453 unop(Iop_Not64, mkexpr(arg_m)))));
3528 binop(shOp, mkexpr(arg_n), mkU8(1)),
3529 binop(shOp, mkexpr(arg_m), mkU8(1))),
3532 unop(notOp, mkexpr(arg_n)),
3533 mkexpr(arg_m)),
3590 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3592 assign(tmp, binop(op2, mkexpr(arg_n), mkexpr(arg_m)));
3593 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
3622 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
3635 binop(op, mkexpr(arg_m), mkexpr(arg_n))));
3681 assign(res, binop(op, mkexpr(arg_m),
3682 unop(Iop_64to8, mkexpr(arg_n))));
3684 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3689 mkexpr(arg_n)));
3691 assign(tmp, binop(sub_op, mkU64(0), mkexpr(arg_n)));
3693 assign(res, binop(op, mkexpr(arg_m),
3694 unop(Iop_64to8, mkexpr(tmp))));
3696 assign(res, binop(op, mkexpr(arg_m), mkexpr(tmp)));
3778 assign(res, binop(op, mkexpr(arg_m), mkexpr(arg_n)));
3784 mkexpr(arg_n),
3791 mkexpr(old_shval),
3793 mkexpr(old_shval),
3803 binop(cmp_gt, mkexpr(shval),
3805 unop(cmp_neq, mkexpr(arg_m))),
3811 assign(mask, binop(cmp_gt, mkexpr(shval),
3814 assign(tmp, binop(op_rev, mkexpr(res),
3815 unop(Iop_64to8, mkexpr(arg_n))));
3817 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
3819 mkexpr(tmp), mkexpr(mask)),
3821 mkexpr(arg_m), mkexpr(mask)),
3917 mkexpr(arg_n),
3924 mkexpr(old_shval),
3926 mkexpr(old_shval),
3933 mkexpr(arg_m),
3936 mkexpr(arg_n),
3937 mkexpr(imm_val)))),
3939 mkexpr(imm_val),
3942 mkexpr(arg_n)))));
3945 mkexpr(arg_m),
3946 unop(Iop_64to8, mkexpr(arg_n))),
3947 mkexpr(round)));
3951 mkexpr(arg_m),
3953 mkexpr(arg_n),
3954 mkexpr(imm_val))),
3956 mkexpr(imm_val),
3959 mkexpr(arg_n)))));
3961 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
3962 mkexpr(round)));
4067 mkexpr(arg_n),
4074 mkexpr(old_shval),
4076 mkexpr(old_shval),
4082 mkexpr(arg_m),
4084 mkexpr(arg_n),
4085 mkexpr(imm_val))),
4087 mkexpr(imm_val),
4090 mkexpr(arg_n)))));
4092 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4093 mkexpr(round)));
4102 binop(cmp_gt, mkexpr(shval),
4104 unop(cmp_neq, mkexpr(arg_m))),
4110 assign(mask, binop(cmp_gt, mkexpr(shval),
4113 assign(tmp, binop(op_rev, mkexpr(res),
4114 unop(Iop_64to8, mkexpr(arg_n))));
4116 assign(tmp, binop(op_rev, mkexpr(res), mkexpr(arg_n)));
4118 mkexpr(tmp), mkexpr(mask)),
4120 mkexpr(arg_m), mkexpr(mask)),
4151 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4176 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4235 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4238 binop(op_sub, mkexpr(arg_n),
4239 mkexpr(arg_m)),
4240 mkexpr(cond)),
4242 binop(op_sub, mkexpr(arg_m),
4243 mkexpr(arg_n)),
4245 mkexpr(cond)))));
4313 assign(cond, binop(op_cmp, mkexpr(arg_n), mkexpr(arg_m)));
4316 binop(op_sub, mkexpr(arg_n),
4317 mkexpr(arg_m)),
4318 mkexpr(cond)),
4320 binop(op_sub, mkexpr(arg_m),
4321 mkexpr(arg_n)),
4323 mkexpr(cond)))));
4324 assign(res, binop(op_add, mkexpr(acc), mkexpr(tmp)));
4359 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4372 mkexpr(arg_n),
4373 mkexpr(arg_m))));
4382 mkexpr(arg_n),
4383 mkexpr(arg_m)))));
4436 binop(op, mkexpr(arg_n), mkexpr(arg_m))));
4462 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4492 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4524 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4527 binop(op2, mkexpr(arg_n),
4529 binop(op2, mkexpr(arg_m),
4560 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4563 binop(op2, mkexpr(arg_n),
4565 binop(op2, mkexpr(arg_m),
4587 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4624 mkexpr(arg_n),
4625 mkexpr(arg_m))));
4629 mkexpr(arg_n),
4630 mkexpr(arg_m))));
4638 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4665 binop(op, mkexpr(arg_n), mkexpr(arg_m))));
4676 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4692 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4706 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4716 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4731 unop(op2, mkexpr(arg_n)),
4732 unop(op2, mkexpr(arg_m))));
4736 unop(op2, mkexpr(arg_n)),
4737 unop(op2, mkexpr(arg_m))));
4761 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4776 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
4785 mkexpr(arg_n),
4786 mkexpr(arg_m)));
4794 mkexpr(arg_n),
4795 mkexpr(arg_m)));
4805 putQReg(dreg, mkexpr(res), condT);
4807 putDRegI64(dreg, mkexpr(res), condT);
4864 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
4911 assign(res, binop(op, mkexpr(tmp),
4914 assign(res, mkexpr(tmp));
4916 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
4967 binop(op, mkexpr(arg_n), mkexpr(arg_m)),
4968 mkexpr(cond)),
4970 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
4971 unop(Iop_NotV128, mkexpr(cond)))),
4973 putQReg(dreg, mkexpr(res), condT);
5021 assign(res, binop(op2, mkexpr(tmp),
5024 assign(res, mkexpr(tmp));
5026 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
5073 binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5074 mkexpr(cond)),
5076 binop(op, mkexpr(arg_m), mkexpr(arg_n)),
5077 unop(Iop_NotV128, mkexpr(cond)))));
5078 putQReg(dreg, mkexpr(res), condT);
5109 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5149 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5150 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5158 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5344 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5346 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)),
5349 putDRegI64(dreg, binop(op2, getDRegI64(dreg), mkexpr(res)),
5406 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5407 putQReg(dreg, binop(op2, getQReg(dreg), mkexpr(res)), condT);
5473 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5475 assign(tmp, binop(op2, getQReg(dreg), mkexpr(res)));
5477 binop(cmp, mkexpr(arg_n), mkU64(imm)),
5478 binop(cmp, mkexpr(arg_m), mkU64(imm))),
5481 setFlag_QC(mkexpr(tmp), binop(add, getQReg(dreg), mkexpr(res)),
5484 putQReg(dreg, binop(add, getQReg(dreg), mkexpr(res)), condT);
5576 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5578 putQReg(dreg, mkexpr(res), condT);
5580 putDRegI64(dreg, mkexpr(res), condT);
5624 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5625 putQReg(dreg, mkexpr(res), condT);
5682 putQReg(dreg, binop(op, mkexpr(arg_n), mkexpr(arg_m)),
5686 binop(op2, mkexpr(arg_n), mkU64(imm)),
5687 binop(op2, mkexpr(arg_m), mkU64(imm))),
5776 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5779 binop(op2, mkexpr(arg_n),
5781 binop(op2, mkexpr(arg_m),
5787 putQReg(dreg, mkexpr(res), condT);
5789 putDRegI64(dreg, mkexpr(res), condT);
5876 assign(res, binop(op, mkexpr(arg_n), mkexpr(arg_m)));
5879 binop(op2, mkexpr(arg_n),
5881 binop(op2, mkexpr(arg_m),
5887 putQReg(dreg, mkexpr(res), condT);
5889 putDRegI64(dreg, mkexpr(res), condT);
6016 mkexpr(reg_m),
6020 mkexpr(reg_m),
6034 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6037 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6045 putQReg(dreg, mkexpr(res), condT);
6047 putDRegI64(dreg, mkexpr(res), condT);
6108 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6111 putQReg(dreg, binop(add, mkexpr(res), getQReg(dreg)),
6114 putDRegI64(dreg, binop(add, mkexpr(res), getDRegI64(dreg)),
6121 putQReg(dreg, mkexpr(res), condT);
6123 putDRegI64(dreg, mkexpr(res), condT);
6156 mkexpr(mask))),
6160 putQReg(dreg, mkexpr(res), condT);
6168 mkexpr(mask))),
6172 putDRegI64(dreg, mkexpr(res), condT);
6205 mkexpr(mask))),
6209 putQReg(dreg, mkexpr(res), condT);
6217 mkexpr(mask))),
6221 putDRegI64(dreg, mkexpr(res), condT);
6245 putQReg(dreg, mkexpr(res), condT);
6247 putDRegI64(dreg, mkexpr(res), condT);
6347 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6349 assign(tmp, binop(op_rev, mkexpr(res), mkU8(shift_imm)));
6350 setFlag_QC(mkexpr(tmp), mkexpr(reg_m), Q, condT);
6353 putQReg(dreg, mkexpr(res), condT);
6355 putDRegI64(dreg, mkexpr(res), condT);
6391 mkexpr(reg_m),
6393 putDRegI64(dreg, mkexpr(res), condT);
6435 mkexpr(reg_m),
6439 mkexpr(reg_m),
6442 putDRegI64(dreg, mkexpr(res), condT);
6531 binop(op, mkexpr(reg_m), mkU8(shift_imm)),
6534 mkexpr(reg_m),
6539 assign(res, binop(op, mkexpr(reg_m), mkU8(shift_imm)));
6542 setFlag_QC(unop(cvt2, unop(cvt, mkexpr(res))), mkexpr(res),
6545 putDRegI64(dreg, unop(cvt, mkexpr(res)), condT);
6576 putQReg(dreg, mkexpr(res), condT);
6669 assign(res, unop(op, mkexpr(arg_m)));
6690 assign(res, unop(op, mkexpr(arg_m)));
6709 assign(res, unop(op, mkexpr(arg_m)));
6738 assign(res, unop(op, mkexpr(arg_m)));
6756 assign(res, unop(op, mkexpr(arg_m)));
6771 assign(res, unop(op, mkexpr(arg_m)));
6778 assign(res, unop(Q ? Iop_Cnt8x16 : Iop_Cnt8x8, mkexpr(arg_m)));
6785 assign(res, unop(Iop_NotV128, mkexpr(arg_m)));
6787 assign(res, unop(Iop_Not64, mkexpr(arg_m)));
6842 assign(res, binop(add_op, unop(op, mkexpr(arg_m)),
6843 mkexpr(arg_d)));
6886 assign(mask, binop(op_cmp, mkexpr(arg_m), zero1));
6887 neg = binop(op_qsub, zero2, mkexpr(arg_m));
6888 neg2 = binop(op_sub, zero2, mkexpr(arg_m));
6891 mkexpr(mask),
6892 mkexpr(arg_m)),
6895 mkexpr(mask)),
6900 mkexpr(mask),
6901 mkexpr(arg_m)),
6904 mkexpr(mask)),
6906 setFlag_QC(mkexpr(res), mkexpr(tmp), Q, condT);
6939 assign(res, binop(op, zero, mkexpr(arg_m)));
6941 setFlag_QC(mkexpr(res), binop(op2, zero, mkexpr(arg_m)),
6952 putQReg(dreg, mkexpr(res), condT);
6954 putDRegI64(dreg, mkexpr(res), condT);
6992 assign(res, binop(op, mkexpr(arg_m), zero));
7012 assign(res, binop(op, mkexpr(arg_m), zero));
7022 binop(op, zero, mkexpr(arg_m))));
7043 assign(res, binop(op, zero, mkexpr(arg_m)));
7053 unop(op, mkexpr(arg_m))));
7074 assign(res, binop(op, zero, mkexpr(arg_m)));
7084 binop(op, mkexpr(arg_m), zero)));
7105 assign(res, binop(op, zero, mkexpr(arg_m)));
7114 assign(res, binop(op, zero, mkexpr(arg_m)));
7133 assign(res, unop(op, mkexpr(arg_m)));
7136 mkexpr(arg_m)));
7153 assign(res, unop(op, mkexpr(arg_m)));
7167 assign(res, binop(op, zero, mkexpr(arg_m)));
7178 putQReg(dreg, mkexpr(res), condT);
7180 putDRegI64(dreg, mkexpr(res), condT);
7190 putQReg(dreg, mkexpr(arg_m), condT);
7195 putDRegI64(dreg, mkexpr(arg_m), condT);
7258 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7259 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7261 putQReg(dreg, mkexpr(res1), condT);
7262 putQReg(mreg, mkexpr(res2), condT);
7264 putDRegI64(dreg, mkexpr(res1), condT);
7265 putDRegI64(mreg, mkexpr(res2), condT);
7309 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7310 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7312 putQReg(dreg, mkexpr(res1), condT);
7313 putQReg(mreg, mkexpr(res2), condT);
7315 putDRegI64(dreg, mkexpr(res1), condT);
7316 putDRegI64(mreg, mkexpr(res2), condT);
7360 assign(res1, binop(op_lo, mkexpr(arg_m), mkexpr(arg_d)));
7361 assign(res2, binop(op_hi, mkexpr(arg_m), mkexpr(arg_d)));
7363 putQReg(dreg, mkexpr(res1), condT);
7364 putQReg(mreg, mkexpr(res2), condT);
7366 putDRegI64(dreg, mkexpr(res1), condT);
7367 putDRegI64(mreg, mkexpr(res2), condT);
7443 setFlag_QC(mkexpr(res), mkexpr(tmp), False, condT);
7445 putDRegI64(dreg, mkexpr(res), condT);
7467 putQReg(dreg, mkexpr(res), condT);
7764 expr = binop(Iop_OrV128, mkexpr(tmp_var), imm_val);
7766 expr = binop(Iop_Or64, mkexpr(tmp_var), imm_val);
7771 expr = binop(Iop_AndV128, mkexpr(tmp_var),
7774 expr = binop(Iop_And64, mkexpr(tmp_var), unop(Iop_Not64, imm_val));
7849 loadLE(Ity_I8, mkexpr(addr))), IRTemp_INVALID);
7853 loadLE(Ity_I16, mkexpr(addr))), IRTemp_INVALID);
7857 loadLE(Ity_I32, mkexpr(addr))), IRTemp_INVALID);
7870 mkexpr(addr),
7880 mkexpr(addr),
7890 mkexpr(addr),
7909 storeLE(mkexpr(addr),
7913 storeLE(mkexpr(addr),
7917 storeLE(mkexpr(addr),
7926 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 1)),
7931 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 2)),
7936 storeLE(binop(Iop_Add32, mkexpr(addr), mkU32(i * 4)),
8001 assign(addr, mkexpr(initialRn));
8051 assign(addr, mkexpr(initialRn));
8060 loadLE(Ity_I8, mkexpr(addr))),
8065 loadLE(Ity_I16, mkexpr(addr))),
8070 loadLE(Ity_I32, mkexpr(addr))),
8082 mkexpr(addr),
8090 mkexpr(addr),
8098 mkexpr(addr),
8126 mkexpr(initialRn),
8134 mkexpr(initialRn),
8135 mkexpr(initialRm));
8188 assign(addr, mkexpr(initialRn));
8197 assign(tmp, binop(Iop_Add32, mkexpr(addr),
8206 mkexpr(initialRn),
8214 mkexpr(initialRn),
8215 mkexpr(initialRm));
8423 assign( res, binop(Iop_Mul32, mkexpr(srcN), mkexpr(srcM)) );
8426 putIRegT( regD, mkexpr(res), condT );
8428 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8480 unop(Iop_64HIto32, mkexpr(irt_prod)),
8483 unop(Iop_64to32, mkexpr(irt_prod)),
8542 binop(Iop_And32, mkexpr(irt_regM_shift), mkU32(mask)),
8603 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
8606 putIRegT( regD, mkexpr(irt_result), condT );
8608 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
8661 or_into_QFLAG32( mkexpr(irt_sat_Q), condT );
8664 putIRegT( regD, mkexpr(irt_result), condT );
8666 putIRegA( regD, mkexpr(irt_result), condT, Ijk_Boring );
8711 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
8713 assign( irt_regN_hi, binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)) );
8716 or_into_QFLAG32( mkexpr(irt_Q_lo), condT );
8719 or_into_QFLAG32( mkexpr(irt_Q_hi), condT );
8722 binop(Iop_Shl32, mkexpr(irt_res_hi), mkU8(16)),
8723 mkexpr(irt_res_lo) );
8770 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
8772 putIRegT( regD, mkexpr(res), condT );
8774 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8776 assign(reso, binop(Iop_HAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
8819 assign(res, binop(Iop_Add16x2, mkexpr(rNt), mkexpr(rMt)));
8821 putIRegT( regD, mkexpr(res), condT );
8823 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8826 binop(Iop_HAdd16Sx2, mkexpr(rNt), mkexpr(rMt))));
8869 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
8871 putIRegT( regD, mkexpr(res), condT );
8873 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8876 binop(Iop_HSub16Ux2, mkexpr(rNt), mkexpr(rMt))));
8919 assign(res, binop(Iop_Sub16x2, mkexpr(rNt), mkexpr(rMt)));
8921 putIRegT( regD, mkexpr(res), condT );
8923 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8926 binop(Iop_HSub16Sx2, mkexpr(rNt), mkexpr(rMt))));
8969 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
8971 putIRegT( regD, mkexpr(res), condT );
8973 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
8975 assign(reso, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9018 assign(res, binop(Iop_Add8x4, mkexpr(rNt), mkexpr(rMt)));
9020 putIRegT( regD, mkexpr(res), condT );
9022 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9025 binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt))));
9068 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9070 putIRegT( regD, mkexpr(res), condT );
9072 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9075 binop(Iop_HSub8Ux4, mkexpr(rNt), mkexpr(rMt))));
9118 assign(res, binop(Iop_Sub8x4, mkexpr(rNt), mkexpr(rMt)));
9120 putIRegT( regD, mkexpr(res), condT );
9122 putIRegA( regD, mkexpr(res), condT, Ijk_Boring );
9125 binop(Iop_HSub8Sx4, mkexpr(rNt), mkexpr(rMt))));
9167 assign(res_q, binop(Iop_QAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
9169 putIRegT( regD, mkexpr(res_q), condT );
9171 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9212 assign(res_q, binop(Iop_QSub8Sx4, mkexpr(rNt), mkexpr(rMt)));
9214 putIRegT( regD, mkexpr(res_q), condT );
9216 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9257 assign(res_q, binop(Iop_QAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9259 putIRegT( regD, mkexpr(res_q), condT );
9261 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9302 assign(res_q, binop(Iop_QSub8Ux4, mkexpr(rNt), mkexpr(rMt)));
9304 putIRegT( regD, mkexpr(res_q), condT );
9306 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9347 assign(res_q, binop(Iop_HAdd8Ux4, mkexpr(rNt), mkexpr(rMt)));
9349 putIRegT( regD, mkexpr(res_q), condT );
9351 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9392 assign(res_q, binop(Iop_HAdd16Ux2, mkexpr(rNt), mkexpr(rMt)));
9394 putIRegT( regD, mkexpr(res_q), condT );
9396 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9437 assign(res_q, binop(Iop_HAdd8Sx4, mkexpr(rNt), mkexpr(rMt)));
9439 putIRegT( regD, mkexpr(res_q), condT );
9441 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9482 assign(res_q, binop(Iop_QAdd16Sx2, mkexpr(rNt), mkexpr(rMt)));
9484 putIRegT( regD, mkexpr(res_q), condT );
9486 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9527 assign(res_q, binop(Iop_QSub16Sx2, mkexpr(rNt), mkexpr(rMt)));
9529 putIRegT( regD, mkexpr(res_q), condT );
9531 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
9585 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9587 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
9594 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9596 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) )) );
9600 binop( Iop_Shl32, mkexpr(irt_diff_res),
9602 binop( Iop_And32, mkexpr(irt_sum_res),
9655 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9657 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9662 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9664 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9670 binop( Iop_Shl32, mkexpr(irt_res_sum), mkU8(16) ),
9671 binop( Iop_And32, mkexpr(irt_res_diff), mkU32(0xFFFF) ) );
9721 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9723 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9727 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9729 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9734 binop( Iop_Shl32, mkexpr(irt_sum), mkU8(16) ),
9735 binop( Iop_And32, mkexpr(irt_diff), mkU32(0xFFFF) ) );
9738 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
9739 put_GEFLAG32( 0, 31, mkexpr(ge10), condT );
9740 put_GEFLAG32( 1, 31, mkexpr(ge10), condT );
9743 assign(ge32, unop(Iop_Not32, mkexpr(irt_sum)));
9744 put_GEFLAG32( 2, 31, mkexpr(ge32), condT );
9745 put_GEFLAG32( 3, 31, mkexpr(ge32), condT );
9804 binop(Iop_Shl32, mkexpr(irt_regN), mkU8(16)),
9807 binop(Iop_Shl32, mkexpr(irt_regM), mkU8(16)),
9810 binop(Iop_Sar32, mkexpr(irt_regN), mkU8(16)),
9811 binop(Iop_Sar32, mkexpr(irt_regM), mkU8(16))) );
9814 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) );
9888 binop( Iop_Shl32, mkexpr(irt_regN), mkU8(16) ),
9891 binop( Iop_Shl32, mkexpr(irt_regM), mkU8(16) ),
9895 binop( Iop_Sar32, mkexpr(irt_regN), mkU8(16) ),
9896 binop( Iop_Sar32, mkexpr(irt_regM), mkU8(16) ) ) );
9898 mkexpr(irt_prod_lo), mkexpr(irt_prod_hi) ) );
9900 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_sum), mkexpr(irt_regA));
9909 signed_overflow_after_Add32( mkexpr(irt_sum),
9978 IRExpr* ire_result = binop(Iop_Add32, mkexpr(irt_prod), mkexpr(irt_regA));
10045 binop(Iop_Shl32, unop(Iop_64HIto32, mkexpr(irt_prod)), mkU8(16)),
10046 binop(Iop_Shr32, unop(Iop_64to32, mkexpr(irt_prod)), mkU8(16))
10049 IRExpr* ire_result = binop(Iop_Add32, mkexpr(prod32), mkexpr(irt_regA));
10108 = binop(Iop_Or32, mkexpr(irt_ge_flag0),
10109 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag0)));
10111 = binop(Iop_Or32, mkexpr(irt_ge_flag1),
10112 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag1)));
10114 = binop(Iop_Or32, mkexpr(irt_ge_flag2),
10115 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag2)));
10117 = binop(Iop_Or32, mkexpr(irt_ge_flag3),
10118 binop(Iop_Sub32, mkU32(0), mkexpr(irt_ge_flag3)));
10197 binop(Iop_Add32, mkexpr(irt_regN), mkexpr(irt_rot)),
10202 binop(Iop_And32, mkexpr(irt_regN), mkU32(0xFFFF0000)),
10203 binop(Iop_And32, mkexpr(irt_rot), mkU32(0xFFFF0000)));
10306 assign(res_q, binop(Iop_QAdd32S, mkexpr(rMt), mkexpr(rNt)));
10308 putIRegT( regD, mkexpr(res_q), condT );
10310 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10314 binop(Iop_Add32, mkexpr(rMt), mkexpr(rNt)), rMt, rNt),
10360 binop(Iop_Add32, mkexpr(rNt), mkexpr(rNt)), rNt, rNt),
10364 assign(rN_d, binop(Iop_QAdd32S, mkexpr(rNt), mkexpr(rNt)));
10365 assign(res_q, binop(Iop_QAdd32S, mkexpr(rMt), mkexpr(rN_d)));
10367 putIRegT( regD, mkexpr(res_q), condT );
10369 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10373 binop(Iop_Add32, mkexpr(rMt), mkexpr(rN_d)), rMt, rN_d),
10416 assign(res_q, binop(Iop_QSub32S, mkexpr(rMt), mkexpr(rNt)));
10418 putIRegT( regD, mkexpr(res_q), condT );
10420 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10424 binop(Iop_Sub32, mkexpr(rMt), mkexpr(rNt)), rMt, rNt),
10470 binop(Iop_Add32, mkexpr(rNt), mkexpr(rNt)), rNt, rNt),
10474 assign(rN_d, binop(Iop_QAdd32S, mkexpr(rNt), mkexpr(rNt)));
10475 assign(res_q, binop(Iop_QSub32S, mkexpr(rMt), mkexpr(rN_d)));
10477 putIRegT( regD, mkexpr(res_q), condT );
10479 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10483 binop(Iop_Sub32, mkexpr(rMt), mkexpr(rN_d)), rMt, rN_d),
10526 assign(res_q, binop(Iop_QSub16Ux2, mkexpr(rNt), mkexpr(rMt)));
10528 putIRegT( regD, mkexpr(res_q), condT );
10530 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10571 assign(res_q, binop(Iop_HAdd16Sx2, mkexpr(rNt), mkexpr(rMt)));
10573 putIRegT( regD, mkexpr(res_q), condT );
10575 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10616 assign(res_q, binop(Iop_HSub8Ux4, mkexpr(rNt), mkexpr(rMt)));
10618 putIRegT( regD, mkexpr(res_q), condT );
10620 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10661 assign(res_q, binop(Iop_HSub16Ux2, mkexpr(rNt), mkexpr(rMt)));
10663 putIRegT( regD, mkexpr(res_q), condT );
10665 putIRegA( regD, mkexpr(res_q), condT, Ijk_Boring );
10720 /* assign(anchorT, binop(Iop_And32, mkexpr(oldRnT), mkU32(~3U))); */
10722 assign(anchorT, mkexpr(oldRnT));
10741 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
10842 binop(opADDorSUB, mkexpr(anchorT),
10856 storeLE( binop(opADDorSUB, mkexpr(anchorT), mkU32(xOff[i])),
10857 r == rN ? mkexpr(oldRnT)
10865 IRExpr* e = binop(opADDorSUB, mkexpr(oldRnT), mkU32(4*nRegs));
11012 mkexpr(rnT),
11018 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
11025 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11027 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11032 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
11045 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11047 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11149 mkexpr(rnT),
11155 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
11162 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11164 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11169 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(8*i));
11182 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11184 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11284 IRExpr* hi32 = unop(Iop_64HIto32, mkexpr(i64));
11285 IRExpr* lo32 = unop(Iop_64to32, mkexpr(i64));
11552 putDReg(dD, loadLE(Ity_F64,mkexpr(ea)), IRTemp_INVALID);
11554 storeLE(mkexpr(ea), getDReg(dD));
11674 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
11699 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
11700 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
11702 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
11793 : mkexpr(mk_get_IR_rounding_mode()));
11797 binop(Iop_F64toI32S, mkexpr(rmode),
11805 binop(Iop_F64toI32U, mkexpr(rmode),
11898 mkexpr(rnT),
11904 assign(taT, summary == 3 ? mkexpr(rnTnew) : mkexpr(rnT));
11911 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11913 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
11918 IRExpr* addr = binop(Iop_Add32, mkexpr(taT), mkU32(4*i));
11931 putIRegT(rN, mkexpr(rnTnew), IRTemp_INVALID);
11933 putIRegA(rN, mkexpr(rnTnew), IRTemp_INVALID, Ijk_Boring);
12014 putFReg(fD, loadLE(Ity_F32,mkexpr(ea)), IRTemp_INVALID);
12016 storeLE(mkexpr(ea), getFReg(fD));
12142 assign(irRes, binop(Iop_CmpF64, mkexpr(argL), mkexpr(argR)));
12167 binop(Iop_And32, mkexpr(oldFPSCR), mkU32(0x0FFFFFFF)),
12168 binop(Iop_Shl32, mkexpr(nzcv), mkU8(28))));
12170 putMiscReg32(OFFB_FPSCR, mkexpr(newFPSCR), condT);
12243 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
12247 mkexpr(rmode),
12255 mkexpr(rmode),
12277 : mkexpr(mk_get_IR_rounding_mode()));
12281 binop(Iop_F64toI32S, mkexpr(rmode),
12290 binop(Iop_F64toI32U, mkexpr(rmode),
12323 assign(rmode, mkexpr(mk_get_IR_rounding_mode()));
12324 putFReg(fD, binop(Iop_F64toF32, mkexpr(rmode), getDReg(dM)),
12382 assign(src32, unop(Iop_64to32, mkexpr(src64)));
12385 mkexpr(src32 ) );
12391 triop(Iop_AddF64, rm, mkexpr(scale), mkexpr(scale)));
12393 IRExpr* resF32 = binop(Iop_F64toF32, mkexpr(rmode), resF64);
12784 assign(res, binop(op, mkexpr(shop), mkexpr(rNt)) );
12788 assign(res, binop(op, mkexpr(rNt),
12789 unop(Iop_Not32, mkexpr(shop))) );
12792 assign(res, binop(op, mkexpr(rNt), mkexpr(shop)) );
12803 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
12852 assign( res, isMVN ? unop(Iop_Not32, mkexpr(shop))
12853 : mkexpr(shop) );
12867 putIRegA( rD, mkexpr(res), condT, jk );
12924 mkexpr(rNt), mkexpr(shop)) );
12961 binop(Iop_Add32, mkexpr(rNt), mkexpr(shop)),
12962 mkexpr(oldC) ));
12967 binop(Iop_Sub32, mkexpr(rNt), mkexpr(shop)),
12968 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
12973 binop(Iop_Sub32, mkexpr(shop), mkexpr(rNt)),
12974 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
12982 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
13153 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
13159 storeLE( mkexpr(taT), mkexpr(rDt) );
13162 storeLE( mkexpr(taT), unop(Iop_32to8, mkexpr(rDt)) );
13181 putIRegA( rD, loadLE(Ity_I32, mkexpr(taT)),
13185 putIRegA( rD, unop(Iop_8Uto32, loadLE(Ity_I8, mkexpr(taT))),
13195 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
13376 storeLE( mkexpr(taT), unop(Iop_32to16, getIRegA(rD)) );
13380 putIRegA( rD, unop(Iop_16Uto32, loadLE(Ity_I16, mkexpr(taT))),
13385 putIRegA( rD, unop(Iop_16Sto32, loadLE(Ity_I16, mkexpr(taT))),
13390 putIRegA( rD, unop(Iop_8Sto32, loadLE(Ity_I8, mkexpr(taT))),
13403 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
13540 unop(Iop_32to1, mkexpr(condT))),
13560 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
13572 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
13607 llPutIReg(15, mkexpr(dst));
13637 unop(Iop_1Uto8,binop(Iop_CmpEQ32, mkexpr(arg),
13639 unop(Iop_Clz32, mkexpr(arg)),
13642 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13666 assign( res, binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) );
13674 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
13678 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13679 mkexpr(oldV)) );
13705 assign(res, binop(Iop_DivS32, mkexpr(argL), mkexpr(argR)));
13706 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13727 assign(res, binop(Iop_DivU32, mkexpr(argL), mkexpr(argR)));
13728 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
13761 mkexpr(argP),
13762 binop(Iop_Mul32, mkexpr(argL), mkexpr(argR)) ));
13771 putIRegA( rD, mkexpr(res), condT, Ijk_Boring );
13775 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13776 mkexpr(oldV)) );
13809 assign( res, binop(mulOp, mkexpr(argL), mkexpr(argR)) );
13810 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
13811 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
13819 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
13820 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
13824 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13825 mkexpr(oldV)) );
13861 mkexpr(old),
13862 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
13863 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
13864 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
13872 putIRegA( rDhi, mkexpr(resHi), condT, Ijk_Boring );
13873 putIRegA( rDlo, mkexpr(resLo), condT, Ijk_Boring );
13877 binop(Iop_Shl32, mkexpr(oldC), mkU8(1)),
13878 mkexpr(oldV)) );
13934 putIRegA( rD, mkexpr(apsr), condT, Ijk_Boring );
13988 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
13990 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
13991 unop(Iop_32to8, mkexpr(tNew))) );
13995 stmt( IRStmt_LLSC(Iend_LE, tOld, mkexpr(tRn),
13997 stmt( IRStmt_LLSC(Iend_LE, tSC1, mkexpr(tRn),
13998 mkexpr(tNew)) );
14000 stmt( IRStmt_Exit(unop(Iop_Not1, mkexpr(tSC1)),
14004 putIRegA(rD, isB ? unop(Iop_8Uto32, mkexpr(tOld)) : mkexpr(tOld),
14056 putIRegA(rT+0, unop(Iop_64to32, mkexpr(res)),
14058 putIRegA(rT+1, unop(Iop_64HIto32, mkexpr(res)),
14064 ? mkexpr(res) : unop(widen, mkexpr(res)),
14117 stmt( IRStmt_LLSC(Iend_LE, resSC1, getIRegA(rN), mkexpr(data)) );
14123 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
14125 putIRegA(rD, mkexpr(resSC32),
14185 assign(dstT, unop(Iop_8Uto32, unop(Iop_32to8, mkexpr(rotT))));
14189 assign(dstT, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rotT))));
14193 assign(dstT, unop(Iop_16Uto32, unop(Iop_32to16, mkexpr(rotT))));
14197 assign(dstT, unop(Iop_16Sto32, unop(Iop_32to16, mkexpr(rotT))));
14201 assign(dstT, binop(Iop_And32, mkexpr(rotT), mkU32(0x00FF00FF)));
14207 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
14208 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
14214 unop(Iop_32to8, mkexpr(lo32))),
14218 unop(Iop_32to8, mkexpr(hi32))),
14227 putIRegA(rD, mkexpr(dstT), condT, Ijk_Boring);
14257 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
14260 mkexpr(olddst),
14264 putIRegA(rD, mkexpr(newdst), condT, Ijk_Boring);
14299 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
14302 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
14305 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
14450 storeLE( binop(Iop_Add32, mkexpr(taT), mkU32(0)), getIRegA(rD+0) );
14451 storeLE( binop(Iop_Add32, mkexpr(taT), mkU32(4)), getIRegA(rD+1) );
14455 loadLE(Ity_I32, binop(Iop_Add32, mkexpr(taT), mkU32(0))),
14458 loadLE(Ity_I32, binop(Iop_Add32, mkexpr(taT), mkU32(4))),
14471 putIRegA( rN, mkexpr(eaT), IRTemp_INVALID, Ijk_Boring );
14510 mkexpr(srcL),
14514 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
14540 mkexpr(srcL),
14544 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
14563 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
14578 putIRegA(rD, mkexpr(res), condT, Ijk_Boring);
14795 mkexpr(r15guard), mkU32(1))),
15103 // binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
15121 // binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
15135 // mkexpr(old_itstate),
15138 // mkexpr(condT1)
15151 // binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
15160 // binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
15171 binop(Iop_Shr32, mkexpr(old_itstate), mkU8(8)));
15186 binop(Iop_And32, mkexpr(old_itstate), mkU32(0xF0)),
15210 we can simply do "assign(condT, mkexpr(condT1))", and the
15216 mkexpr(old_itstate),
15219 mkexpr(condT1)
15229 binop(Iop_And32, mkexpr(old_itstate), mkU32(1)),
15238 binop(Iop_And32, mkexpr(notInITt), mkexpr(condT)));
15325 putIRegT(rD, binop(Iop_Sub32, mkexpr(zero), mkexpr(arg)), condT);
15343 putIRegT(rD, mkexpr(res), condT);
15374 putIRegT(rD, mkexpr(res), condT);
15395 putIRegT(rD, mkexpr(res), condT);
15415 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
15416 mkexpr(oldC)));
15418 putIRegT(rD, mkexpr(res), condT);
15438 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
15439 binop(Iop_Xor32, mkexpr(oldC), mkU32(1))));
15441 putIRegT(rD, mkexpr(res), condT);
15546 putIRegT(rD, mkexpr(res), condT);
15563 putIRegT(rD, mkexpr(res), condT);
15614 llPutIReg(15, mkexpr(dst));
15638 llPutIReg(15, mkexpr(dst));
15694 putIRegT( rD, mkexpr(res), condT );
15703 irsb->next = binop(Iop_Or32, mkexpr(res), mkU32(1));
15744 putIRegT( rD, mkexpr(val), condT );
15753 llPutIReg(15, binop(Iop_Or32, mkexpr(val), mkU32(1)));
15808 stmt(IRStmt_Exit( mkexpr(kond),
15861 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
15866 assign(base, binop(Iop_And32, mkexpr(newSP), mkU32(~3)));
15872 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(4 * nRegs)),
15918 assign(base, binop(Iop_And32, mkexpr(oldSP), mkU32(~3)));
15924 assign(newSP, binop(Iop_Add32, mkexpr(oldSP),
15932 binop(Iop_Add32, mkexpr(base),
15943 binop(Iop_Add32, mkexpr(base),
15948 putIRegT(13, mkexpr(newSP), IRTemp_INVALID);
15959 llPutIReg(15, mkexpr(newPC));
15983 mkexpr(argL), mkexpr(argR)),
16004 mkexpr(argL), mkexpr(argR)),
16159 mkexpr(argL), mkexpr(argR)), condT );
16214 putIRegT(rD, mkexpr(res), condT);
16236 putIRegT(rD, loadLE(Ity_I32, mkexpr(ea)),
16368 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
16375 binop(Iop_Add32, mkexpr(base),
16384 binop(Iop_Add32, mkexpr(oldRn),
16422 assign(base, binop(Iop_And32, mkexpr(oldRn), mkU32(~3U)));
16427 storeLE( binop(Iop_Add32, mkexpr(base), mkU32(nRegs * 4 - 4)),
16432 binop(Iop_Add32, mkexpr(oldRn),
16486 putIRegT(rD, mkexpr(res), condT);
16535 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
16724 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
16725 putIRegT(rD, mkexpr(res), condT);
16751 assign(res, binop(Iop_Add32, mkexpr(argL), mkexpr(argR)));
16752 putIRegT(rD, mkexpr(res), condT);
16800 mkexpr(argL), mkexpr(argR)));
16834 ? binop(Iop_Sub32, mkexpr(argR), mkexpr(argL))
16835 : binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
16836 putIRegT(rD, mkexpr(res), condT);
16866 assign(res, binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)));
16867 putIRegT(rD, mkexpr(res), condT);
16899 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
16900 mkexpr(oldC) ));
16901 putIRegT(rD, mkexpr(res), condT);
16910 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
16911 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
16912 putIRegT(rD, mkexpr(res), condT);
16961 assign(res, binop(op, mkexpr(argL), mkexpr(argR)));
16962 putIRegT(rD, mkexpr(res), condT);
17032 ? binop(op, mkexpr(argR), mkexpr(argL))
17033 : binop(op, mkexpr(argL), mkexpr(argR)));
17035 putIRegT(rD, mkexpr(res), condT);
17095 binop(Iop_Add32, mkexpr(argL), mkexpr(argR)),
17096 mkexpr(oldC) ));
17097 putIRegT(rD, mkexpr(res), condT);
17106 binop(Iop_Sub32, mkexpr(argL), mkexpr(argR)),
17107 binop(Iop_Xor32, mkexpr(oldC), mkU32(1)) ));
17108 putIRegT(rD, mkexpr(res), condT);
17172 assign(res, binop(op, mkexpr(rNt),
17173 unop(Iop_Not32, mkexpr(argR))));
17175 assign(res, binop(op, mkexpr(rNt), mkexpr(argR)));
17178 putIRegT(rD, mkexpr(res), condT);
17221 putIRegT(rD, mkexpr(res), condT);
17254 assign(res, isMVN ? unop(Iop_Not32, mkexpr(oldRn))
17255 : mkexpr(oldRn));
17257 putIRegT(rD, mkexpr(res), condT);
17301 mkexpr(argL), mkexpr(argR)));
17358 putIRegT(rD, mkexpr(res), condT);
17402 putIRegT(rD, mkexpr(res), condT);
17488 mkexpr(preAddr), mkU32(imm8)));
17511 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
17517 storeLE(mkexpr(transAddr),
17518 unop(Iop_32to8, mkexpr(oldRt)));
17521 storeLE(mkexpr(transAddr),
17522 unop(Iop_32to16, mkexpr(oldRt)));
17525 storeLE(mkexpr(transAddr), mkexpr(oldRt));
17549 assign(newRt, loadLE(ty, mkexpr(transAddr)));
17551 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
17555 llPutIReg(rT, mkexpr(newRt));
17557 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17563 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
17569 llPutIReg(15, mkexpr(newRt));
17673 storeLE(mkexpr(transAddr),
17674 unop(Iop_32to8, mkexpr(oldRt)));
17677 storeLE(mkexpr(transAddr),
17678 unop(Iop_32to16, mkexpr(oldRt)));
17681 storeLE(mkexpr(transAddr), mkexpr(oldRt));
17700 assign(newRt, loadLE(ty, mkexpr(transAddr)));
17702 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
17711 llPutIReg(rT, mkexpr(newRt));
17713 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17718 llPutIReg(15, mkexpr(newRt));
17812 binop( Iop_Add32, mkexpr(rNt), mkU32(imm12) ));
17819 storeLE(mkexpr(transAddr),
17820 unop(Iop_32to8, mkexpr(oldRt)));
17823 storeLE(mkexpr(transAddr),
17824 unop(Iop_32to16, mkexpr(oldRt)));
17827 storeLE(mkexpr(transAddr), mkexpr(oldRt));
17846 assign(newRt, loadLE(ty, mkexpr(transAddr)));
17848 assign(newRt, unop(widen, loadLE(ty, mkexpr(transAddr))));
17850 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17854 irsb->next = mkexpr(newRt);
17900 mkexpr(preAddr), mkU32(imm8 << 2)));
17909 storeLE(mkexpr(transAddr),
17910 mkexpr(oldRt));
17911 storeLE(binop(Iop_Add32, mkexpr(transAddr), mkU32(4)),
17912 mkexpr(oldRt2));
17918 mkexpr(transAddr)));
17921 binop(Iop_Add32, mkexpr(transAddr), mkU32(4))));
17922 putIRegT(rT, mkexpr(newRt), IRTemp_INVALID);
17923 putIRegT(rT2, mkexpr(newRt2), IRTemp_INVALID);
17927 putIRegT(rN, mkexpr(postAddr), IRTemp_INVALID);
17974 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
18060 binop(Iop_Shl32, mkexpr(delta), mkU8(1))
18096 binop(Iop_Shr32, mkexpr(src), mkU8(lsb)),
18099 binop(Iop_Shl32, mkexpr(tmp), mkU8(31-wm1)),
18102 putIRegT(rD, mkexpr(res), condT);
18140 unop(Iop_32to8, mkexpr(rotT))));
18145 mkexpr(rotT))));
18150 unop(Iop_32to8, mkexpr(rotT))));
18155 unop(Iop_32to16, mkexpr(rotT))));
18159 assign(dstT, binop(Iop_And32, mkexpr(rotT),
18166 assign(lo32, binop(Iop_And32, mkexpr(rotT), mkU32(0xFF)));
18167 assign(hi32, binop(Iop_Shr32, mkexpr(rotT), mkU8(16)));
18173 unop(Iop_32to8, mkexpr(lo32))),
18177 unop(Iop_32to8, mkexpr(hi32))),
18185 putIRegT(rD, mkexpr(dstT), condT);
18200 putIRegT(rD, mkexpr(res), condT);
18218 assign(res, binop(Iop_DivS32, mkexpr(argL), mkexpr(argR)));
18219 putIRegT(rD, mkexpr(res), condT);
18237 assign(res, binop(Iop_DivU32, mkexpr(argL), mkexpr(argR)));
18238 putIRegT(rD, mkexpr(res), condT);
18257 putIRegT( rDhi, unop(Iop_64HIto32, mkexpr(res)), condT );
18258 putIRegT( rDlo, unop(Iop_64to32, mkexpr(res)), condT );
18281 putIRegT(rD, mkexpr(res), condT);
18328 mkexpr(old),
18329 binop(mulOp, mkexpr(argL), mkexpr(argR))) );
18330 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
18331 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
18332 putIRegT( rDhi, mkexpr(resHi), condT );
18333 putIRegT( rDlo, mkexpr(resLo), condT );
18380 binop(Iop_Shl32, mkexpr(src), mkU8(lsb)),
18383 mkexpr(olddst),
18387 putIRegT(rD, mkexpr(newdst), condT);
18418 mkexpr(srcL),
18422 putIRegT(rD, mkexpr(res), condT);
18447 mkexpr(srcL),
18451 putIRegT(rD, mkexpr(res), condT);
18471 mkexpr(arg),
18473 unop(Iop_Clz32, mkexpr(arg)),
18476 putIRegT(rD, mkexpr(res), condT);
18493 putIRegT(rD, mkexpr(res), condT);
18513 putIRegT(rD, mkexpr(res), condT);
18541 putIRegT( rD, mkexpr(apsr), condT );
18562 putIRegT(rT, mkexpr(res), IRTemp_INVALID);
18582 putIRegT(rT, unop(isH ? Iop_16Uto32 : Iop_8Uto32, mkexpr(res)),
18604 putIRegT(rT, unop(Iop_64to32, mkexpr(res)), IRTemp_INVALID);
18605 putIRegT(rT2, unop(Iop_64HIto32, mkexpr(res)), IRTemp_INVALID);
18633 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
18634 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
18662 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
18663 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
18687 stmt( IRStmt_LLSC(Iend_LE, resSC1, getIRegT(rN), mkexpr(data)));
18692 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
18693 putIRegT(rD, mkexpr(resSC32), IRTemp_INVALID);
