Lines Matching refs:unop
306 static IRExpr* unop ( IROp op, IRExpr* a )
364 loaded = unop(Iop_8Uto32, loadLE(Ity_I8, addr)); break;
366 loaded = unop(Iop_8Sto32, loadLE(Ity_I8, addr)); break;
368 loaded = unop(Iop_16Uto32, loadLE(Ity_I16, addr)); break;
370 loaded = unop(Iop_16Sto32, loadLE(Ity_I16, addr)); break;
1429 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1446 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1464 unop(Iop_Not1, unop(Iop_32to1, mkexpr(guardT))),
1540 unop(Iop_1Uto32,
1548 = unop(Iop_1Uto32, binop(Iop_CmpNE32, get_GEFLAG32(0), mkU32(0)));
1550 = unop(Iop_1Uto32, binop(Iop_CmpNE32, get_GEFLAG32(1), mkU32(0)));
1552 = unop(Iop_1Uto32, binop(Iop_CmpNE32, get_GEFLAG32(2), mkU32(0)));
1554 = unop(Iop_1Uto32, binop(Iop_CmpNE32, get_GEFLAG32(3), mkU32(0)));
1822 unop(Iop_32to8,
1848 unop(Iop_32to8,
1932 unop(Iop_32to8,
1958 unop(Iop_32to8,
2042 unop(Iop_32to8,
2070 unop(
2106 unop(Iop_32to8,
2129 unop(Iop_32to8, mkexpr(amt5T))
2133 unop(Iop_32to8,
2994 unop(Iop_Not64, mkexpr(old_mask))),
3054 assign(res, unop(op, binop(op2, mkexpr(arg_m), mkU8(index))));
3368 unop(Iop_NotV128, mkexpr(arg_m))));
3371 unop(Iop_Not64, mkexpr(arg_m))));
3402 unop(Iop_NotV128, mkexpr(arg_m))));
3405 unop(Iop_Not64, mkexpr(arg_m))));
3439 unop(Iop_NotV128,
3450 unop(Iop_Not64, mkexpr(reg_d)))));
3467 unop(Iop_NotV128, mkexpr(arg_m)))));
3477 unop(Iop_Not64, mkexpr(arg_m)))));
3494 unop(Iop_NotV128, mkexpr(arg_m)))));
3504 unop(Iop_Not64, mkexpr(arg_m)))));
3585 unop(notOp, mkexpr(arg_n)),
3685 unop(Q ? Iop_NotV128 : Iop_Not64,
3733 unop(Iop_64to8, mkexpr(arg_n))));
3745 unop(Iop_64to8, mkexpr(tmp))));
3855 unop(cmp_neq, mkexpr(arg_m))),
3865 unop(Iop_64to8, mkexpr(arg_n))));
3983 unop(Iop_64to8,
3995 unop(Iop_64to8, mkexpr(arg_n))),
4152 unop(cmp_neq, mkexpr(arg_m))),
4162 unop(Iop_64to8, mkexpr(arg_n))));
4291 unop(Q ? Iop_NotV128 : Iop_Not64,
4369 unop(Q ? Iop_NotV128 : Iop_Not64,
4418 assign(res, unop(op, binop(Q ? Iop_AndV128 : Iop_And64,
4426 assign(res, unop(Q ? Iop_NotV128 : Iop_Not64,
4427 unop(op,
4670 assign(res, unop(Iop_Abs32Fx4,
4676 assign(res, unop(Iop_Abs32Fx2,
4782 unop(op2, mkexpr(arg_n)),
4783 unop(op2, mkexpr(arg_m))));
4787 unop(op2, mkexpr(arg_n)),
4788 unop(op2, mkexpr(arg_m))));
4927 assign(arg_n, unop(cvt, getDRegI64(nreg)));
4929 assign(arg_m, unop(cvt, getDRegI64(mreg)));
4982 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
5026 assign(arg_n, unop(cvt, getDRegI64(nreg)));
5027 assign(arg_m, unop(cvt, getDRegI64(mreg)));
5028 assign(cond, unop(cvt2, binop(cmp, getDRegI64(nreg),
5037 unop(Iop_NotV128, mkexpr(cond)))),
5092 putDRegI64(dreg, unop(cvt, binop(sh, mkexpr(res), mkU8(8 << size))),
5133 assign(arg_n, unop(cvt, getDRegI64(nreg)));
5134 assign(arg_m, unop(cvt, getDRegI64(mreg)));
5135 assign(cond, unop(cvt2, binop(cmp, getDRegI64(nreg),
5143 unop(Iop_NotV128, mkexpr(cond)))));
5349 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5374 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5453 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5512 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5586 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5611 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5681 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5725 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5791 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5816 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5889 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
5914 assign(arg_m, unop(dup, binop(get, getDRegI64(mreg), mkU8(index))));
6213 unop(Iop_NotV128,
6225 unop(Iop_Not64,
6262 unop(Iop_NotV128,
6274 unop(Iop_Not64,
6445 assign(res, unop(narOp,
6488 assign(res, unop(narOp,
6597 setFlag_QC(unop(cvt2, unop(cvt, mkexpr(res))), mkexpr(res),
6599 putDRegI64(dreg, unop(cvt, mkexpr(res)), condT);
6629 assign(res, binop(op, unop(cvt, getDRegI64(mreg)), mkU8(shift_imm)));
6723 assign(res, unop(op, mkexpr(arg_m)));
6744 assign(res, unop(op, mkexpr(arg_m)));
6763 assign(res, unop(op, mkexpr(arg_m)));
6792 assign(res, unop(op, mkexpr(arg_m)));
6810 assign(res, unop(op, mkexpr(arg_m)));
6825 assign(res, unop(op, mkexpr(arg_m)));
6832 assign(res, unop(Q ? Iop_Cnt8x16 : Iop_Cnt8x8, mkexpr(arg_m)));
6839 assign(res, unop(Iop_NotV128, mkexpr(arg_m)));
6841 assign(res, unop(Iop_Not64, mkexpr(arg_m)));
6896 assign(res, binop(add_op, unop(op, mkexpr(arg_m)),
6948 unop(Q ? Iop_NotV128 : Iop_Not64,
6956 unop(Q ? Iop_NotV128 : Iop_Not64,
7071 assign(res, unop(Q ? Iop_NotV128 : Iop_Not64,
7102 assign(res, unop(Q ? Iop_NotV128 : Iop_Not64,
7103 unop(op, mkexpr(arg_m))));
7133 assign(res, unop(Q ? Iop_NotV128 : Iop_Not64,
7183 assign(res, unop(op, mkexpr(arg_m)));
7185 assign(res, unop(Q ? Iop_Abs32Fx4 : Iop_Abs32Fx2,
7203 assign(res, unop(op, mkexpr(arg_m)));
7433 putDRegI64(dreg, unop(op, getQReg(mreg)), condT);
7490 assign(res, unop(op, getQReg(mreg)));
7491 assign(tmp, unop(op2, getQReg(mreg)));
7513 assign(res, binop(op, unop(cvt, getDRegI64(mreg)),
7528 putQReg(dreg, unop(Iop_F16toF32x4, getDRegI64(mreg)),
7535 putDRegI64(dreg, unop(Iop_F32toF16x4, getQReg(mreg)),
7554 putQReg(dreg, unop(op, getQReg(mreg)), condT);
7558 putDRegI64(dreg, unop(op, getDRegI64(mreg)), condT);
7576 putQReg(dreg, unop(op, getQReg(mreg)), condT);
7579 putDRegI64(dreg, unop(op, getDRegI64(mreg)), condT);
7613 putQReg(dreg, unop(op, getQReg(mreg)), condT);
7615 putDRegI64(dreg, unop(op, getDRegI64(mreg)), condT);
7795 putQReg(dreg, unop(Iop_NotV128, imm_val), condT);
7797 putDRegI64(dreg, unop(Iop_Not64, imm_val), condT);
7820 unop(Iop_NotV128, imm_val));
7822 expr = binop(Iop_And64, mkexpr(tmp_var), unop(Iop_Not64, imm_val));
8496 putDRegI64(rD + r, unop(Iop_Dup8x8,
8501 putDRegI64(rD + r, unop(Iop_Dup16x4,
8506 putDRegI64(rD + r, unop(Iop_Dup32x2,
8517 unop(Iop_Dup8x8,
8525 unop(Iop_Dup16x4,
8533 unop(Iop_Dup32x2,
9107 unop(Iop_64HIto32, mkexpr(irt_prod)),
9110 unop(Iop_64to32, mkexpr(irt_prod)),
9171 unop(Iop_Not32, mkU32(mask))) );
9516 assign(reso, unop(Iop_Not32,
9566 assign(reso, unop(Iop_Not32,
9616 assign(reso, unop(Iop_Not32,
9715 assign(reso, unop(Iop_Not32,
9765 assign(reso, unop(Iop_Not32,
9815 assign(reso, unop(Iop_Not32,
10423 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
10428 assign(ge32, unop(Iop_Not32, mkexpr(irt_sum)));
10739 assign( irt_resHi, unop(Iop_64HIto32, mkexpr(irt_res)) );
10740 assign( irt_resLo, unop(Iop_64to32, mkexpr(irt_res)) );
10805 binop(Iop_Shl32, unop(Iop_64HIto32, mkexpr(irt_prod)), mkU8(16)),
10806 binop(Iop_Shr32, unop(Iop_64to32, mkexpr(irt_prod)), mkU8(16))
10904 unop(Iop_Not32, ire_ge_flags)));
11651 unop( Iop_16Uto32,
11652 unop( Iop_32to16, mkexpr(irt_regN) )
11659 unop( Iop_16Uto32,
11660 unop( Iop_32to16, mkexpr(irt_regM) )
11678 assign(ge32, unop(Iop_Not32, mkexpr(irt_diff)));
11729 unop( Iop_16Uto32,
11730 unop( Iop_32to16, mkexpr(irt_regN) )
11737 unop( Iop_16Uto32,
11738 unop( Iop_32to16, mkexpr(irt_regM) )
11747 assign(ge10, unop(Iop_Not32, mkexpr(irt_diff)));
11823 assign(ge10, unop(Iop_Not32, mkexpr(irt_sum)));
11828 assign(ge32, unop(Iop_Not32, mkexpr(irt_diff)));
11929 unop(Iop_16Uto32,
11930 unop(Iop_8Sto16,
11931 unop(Iop_32to8, mkexpr(irt_rot))))),
11939 unop(Iop_16Uto32,
11940 unop(Iop_8Sto16,
11941 unop(Iop_32to8,
12000 unop(Iop_16Sto32,
12001 unop(Iop_32to16,
12005 unop(Iop_16Sto32,
12006 unop(Iop_32to16,
12017 unop(Iop_16Sto32,
12018 unop(Iop_32to16,
12024 unop(Iop_16Sto32,
12025 unop(Iop_32to16, mkexpr(rMt)
12033 unop(Iop_16Uto32,
12034 unop(Iop_32to16,
12097 unop(Iop_16Uto32,
12098 unop(Iop_32to16,
12102 unop(Iop_16Uto32,
12103 unop(Iop_32to16,
12114 unop(Iop_16Uto32,
12115 unop(Iop_32to16,
12121 unop(Iop_16Uto32,
12122 unop(Iop_32to16, mkexpr(rMt)
12130 unop(Iop_16Uto32,
12131 unop(Iop_32to16,
12194 unop(Iop_16Sto32,
12195 unop(Iop_32to16,
12199 unop(Iop_16Sto32,
12200 unop(Iop_32to16,
12211 unop(Iop_16Sto32,
12212 unop(Iop_32to16,
12218 unop(Iop_16Sto32,
12219 unop(Iop_32to16, mkexpr(rMt)
12227 unop(Iop_16Uto32,
12228 unop(Iop_32to16,
12291 unop(Iop_16Uto32,
12292 unop(Iop_32to16,
12296 unop(Iop_16Uto32,
12297 unop(Iop_32to16,
12308 unop(Iop_16Uto32,
12309 unop(Iop_32to16,
12315 unop(Iop_16Uto32,
12316 unop(Iop_32to16, mkexpr(rMt)
12324 unop(Iop_16Uto32,
12325 unop(Iop_32to16,
12436 = unop(Iop_64HIto32,
12502 unop(Iop_16Sto32,
12503 unop(Iop_32to16, mkexpr(irt_rN))
12505 unop(Iop_16Sto32,
12506 unop(Iop_32to16, mkexpr(op_2))
12526 assign( resHi, unop(Iop_64HIto32, mkexpr(result)) );
12527 assign( resLo, unop(Iop_64to32, mkexpr(result)) );
12590 unop(Iop_16Sto32,
12591 unop(Iop_32to16, mkexpr(irt_rN))
12593 unop(Iop_16Sto32,
12594 unop(Iop_32to16, mkexpr(op_2))
12614 assign( resHi, unop(Iop_64HIto32, mkexpr(result)) );
12615 assign( resLo, unop(Iop_64to32, mkexpr(result)) );
12652 assign( hi64, unop(Iop_V128HIto64, mkexpr(t128)) );
12653 assign( lo64, unop(Iop_V128to64, mkexpr(t128)) );
12664 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
12665 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
12666 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
12667 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
13131 unop(Iop_64HIto32, mkexpr(srcN)),
13132 unop(Iop_64to32, mkexpr(srcN)),
13133 unop(Iop_64HIto32, mkexpr(srcM)),
13134 unop(Iop_64to32, mkexpr(srcM)));
13236 case 0: data = unop(Iop_32to8, data); break;
13237 case 1: data = unop(Iop_32to16, data); break;
13428 PUT_IREG(tt, unop(Iop_64to32, mkexpr(res)));
13429 PUT_IREG(tt2, unop(Iop_64HIto32, mkexpr(res)));
13432 ? mkexpr(res) : unop(widen, mkexpr(res)));
13461 : unop(narrow, GET_IREG(tt)));
13471 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
13529 IRExpr* res = IRExpr_ITE(unop(Iop_32to1, mkexpr(guard)), srcN, srcM);
13681 srcM = unop(Iop_F32toF64, srcM);
13686 llPutFReg(dd, unop(Iop_ReinterpI32asF32, mkexpr(res)));
13918 assign(r0, unop(Iop_ReinterpI32asF32,
13919 binop(cvt, rmE, unop(Iop_F32toF64,
13921 assign(r1, unop(Iop_ReinterpI32asF32,
13922 binop(cvt, rmE, unop(Iop_F32toF64,
13925 assign(r2, unop(Iop_ReinterpI32asF32,
13926 binop(cvt, rmE, unop(Iop_F32toF64,
13928 assign(r3, unop(Iop_ReinterpI32asF32,
13929 binop(cvt, rmE, unop(Iop_F32toF64,
14623 unop(Iop_ReinterpI64asF64,
14644 assign(i64, unop(Iop_ReinterpF64asI64, getDReg(dM)));
14645 IRExpr* hi32 = unop(Iop_64HIto32, mkexpr(i64));
14646 IRExpr* lo32 = unop(Iop_64to32, mkexpr(i64));
14670 unop(Iop_ReinterpI32asF32, isT ? getIRegT(rN) : getIRegA(rN)),
14673 unop(Iop_ReinterpI32asF32, isT ? getIRegT(rM) : getIRegA(rM)),
14690 IRExpr* res0 = unop(Iop_ReinterpF32asI32, getFReg(sD));
14691 IRExpr* res1 = unop(Iop_ReinterpF32asI32, getFReg(sD+1));
14719 unop(Iop_32to8,
14730 unop(Iop_32to16,
14764 IRExpr* e = unop(U ? Iop_8Uto32 : Iop_8Sto32,
14778 IRExpr* e = unop(U ? Iop_16Uto32 : Iop_16Sto32,
14816 putFReg(rD, unop(Iop_ReinterpI32asF32, mkU32(imm)), condT);
14832 putDReg(rD, unop(Iop_ReinterpI64asF64, mkU64(imm)), condT);
14854 putQReg(rD, unop(Iop_Dup32x4, e), condT);
14857 putQReg(rD, unop(Iop_Dup16x8, unop(Iop_32to16, e)),
14861 putQReg(rD, unop(Iop_Dup8x16, unop(Iop_32to8, e)),
14871 putDRegI64(rD, unop(Iop_Dup32x2, e), condT);
14874 putDRegI64(rD, unop(Iop_Dup16x4, unop(Iop_32to16, e)),
14878 putDRegI64(rD, unop(Iop_Dup8x8, unop(Iop_32to8, e)),
14948 unop(Iop_NegF64,
14956 unop(Iop_NegF64, getDReg(dD)),
14964 unop(Iop_NegF64, getDReg(dD)),
14965 unop(Iop_NegF64,
14977 putDReg(dD, unop(Iop_NegF64,
15002 unop(Iop_NegF64, getDReg(dD)),
15013 unop(Iop_NegF64, getDReg(dD)),
15015 unop(Iop_NegF64, getDReg(dN)),
15036 unop(Iop_NegF64, getDReg(dN)),
15135 putDReg(dD, unop(Iop_AbsF64, getDReg(dM)), condT);
15141 putDReg(dD, unop(Iop_NegF64, getDReg(dM)), condT);
15171 putDReg(dD, unop(Iop_I32StoF64,
15172 unop(Iop_ReinterpF32asI32, getFReg(fM))),
15177 putDReg(dD, unop(Iop_I32UtoF64,
15178 unop(Iop_ReinterpF32asI32, getFReg(fM))),
15200 putFReg(fD, unop(Iop_ReinterpI32asF32,
15208 putFReg(fD, unop(Iop_ReinterpI32asF32,
15377 IRExpr* res = unop(Iop_ReinterpF32asI32, getFReg(fN));
15384 putFReg(fN, unop(Iop_ReinterpI32asF32,
15455 unop(Iop_NegF32,
15463 unop(Iop_NegF32, getFReg(fD)),
15470 unop(Iop_NegF32, getFReg(fD)),
15471 unop(Iop_NegF32,
15484 putFReg(fD, unop(Iop_NegF32,
15509 unop(Iop_NegF32, getFReg(fD)),
15520 unop(Iop_NegF32, getFReg(fD)),
15522 unop(Iop_NegF32, getFReg(fN)),
15543 unop(Iop_NegF32, getFReg(fN)),
15586 assign(argL, unop(Iop_F32toF64, getFReg(fD)));
15588 : unop(Iop_F32toF64, getFReg(fM)));
15649 putFReg(fD, unop(Iop_AbsF32, getFReg(fM)), condT);
15655 putFReg(fD, unop(Iop_NegF32, getFReg(fM)), condT);
15695 unop(Iop_I32StoF64,
15696 unop(Iop_ReinterpF32asI32, getFReg(fM)))),
15703 unop(Iop_I32UtoF64,
15704 unop(Iop_ReinterpF32asI32, getFReg(fM)))),
15727 putFReg(fD, unop(Iop_ReinterpI32asF32,
15729 unop(Iop_F32toF64, getFReg(fM)))),
15736 putFReg(fD, unop(Iop_ReinterpI32asF32,
15738 unop(Iop_F32toF64, getFReg(fM)))),
15756 putDReg(dD, unop(Iop_F32toF64, getFReg(fM)), condT);
15810 assign(scale, unop(Iop_I32UtoF64, mkU32( ((UInt)1) << (frac_bits-1) )));
15820 assign(src32, unop(Iop_ReinterpF32asI32, getFReg(d)));
15821 IRExpr* as_F64 = unop( unsyned ? Iop_I32UtoF64 : Iop_I32StoF64,
15839 assign(src32, unop(Iop_64to32, getDRegI64(d)));
15840 IRExpr* as_F64 = unop( unsyned ? Iop_I32UtoF64 : Iop_I32StoF64,
15866 putDRegI64(d, unop(unsyned ? Iop_32Uto64 : Iop_32Sto64,
15880 rm, unop(Iop_F32toF64, mkexpr(srcF32)),
15888 putFReg(d, unop(Iop_ReinterpI32asF32, mkexpr(asI32)), condT);
16297 unop(Iop_Not32, mkexpr(shop))) );
16360 assign( res, isMVN ? unop(Iop_Not32, mkexpr(shop))
16660 storeGuardedLE( mkexpr(taT), unop(Iop_32to8, mkexpr(rDt)), condT );
16897 unop(Iop_32to16, getIRegA(rD)), condT );
17065 stmt( IRStmt_Exit( unop(Iop_Not1,
17066 unop(Iop_32to1, mkexpr(condT))),
17085 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
17096 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
17163 unop(Iop_Clz32, mkexpr(arg))
17333 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
17334 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
17386 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
17387 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
17436 unop(Iop_32Uto64, mkexpr(argDhi))),
17437 unop(Iop_32Uto64, mkexpr(argDlo))) );
17438 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
17439 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
17552 unop(Iop_32to8, mkexpr(tNew))) );
17561 stmt( IRStmt_Exit(unop(Iop_Not1, mkexpr(tSC1)),
17565 putIRegA(rD, isB ? unop(Iop_8Uto32, mkexpr(tOld)) : mkexpr(tOld),
17617 putIRegA(rT+0, unop(Iop_64to32, mkexpr(res)),
17619 putIRegA(rT+1, unop(Iop_64HIto32, mkexpr(res)),
17625 ? mkexpr(res) : unop(widen, mkexpr(res)),
17675 : unop(narrow, getIRegA(rT)));
17684 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
17746 assign(dstT, unop(Iop_8Uto32, unop(Iop_32to8, mkexpr(rotT))));
17750 assign(dstT, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rotT))));
17754 assign(dstT, unop(Iop_16Uto32, unop(Iop_32to16, mkexpr(rotT))));
17758 assign(dstT, unop(Iop_16Sto32, unop(Iop_32to16, mkexpr(rotT))));
17774 unop(Iop_8Sto32,
17775 unop(Iop_32to8, mkexpr(lo32))),
17778 unop(Iop_8Sto32,
17779 unop(Iop_32to8, mkexpr(hi32))),
18102 unop(isU ? Iop_8Uto32 : Iop_8Sto32,
18103 unop(Iop_32to8,
18132 unop(isU ? Iop_16Uto32 : Iop_16Sto32,
18133 unop(Iop_32to16,
18216 = unop(Iop_64HIto32,
18238 = unop(Iop_64HIto32,
18542 IRExpr* data = unop(Iop_32to8, getIRegA(rT));
18569 IRExpr* data = unop(Iop_32to8, getIRegA(rT));
18596 IRExpr* data = unop(Iop_32to16, getIRegA(rT));
18621 IRExpr* data = unop(Iop_32to16, getIRegA(rT));
18775 stmt( IRStmt_Exit( unop(Iop_32to1,
18905 unop(Iop_32to1,
19260 // unop(Iop_32to8, binop(Iop_And32,
19468 assign(res, unop(Iop_Not32, getIRegT(rM)));
19519 unop(Iop_Not32, getIRegT(rM) )));
20210 storeGuardedLE( ea, unop(Iop_32to16, getIRegT(rD)), condT );
20271 storeGuardedLE( ea, unop(Iop_32to8, getIRegT(rD)), condT );
20425 storeGuardedLE( ea, unop(Iop_32to16, getIRegT(rD)), condT );
20450 storeGuardedLE( ea, unop(Iop_32to8, getIRegT(rD)), condT );
20664 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
20695 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(condT)),
21328 unop(Iop_Not32, mkexpr(argR))));
21412 assign(res, isMVN ? unop(Iop_Not32, mkexpr(oldRn))
21679 data = unop(Iop_32to8, mkexpr(oldRt));
21682 data = unop(Iop_32to16, mkexpr(oldRt));
21847 data = unop(Iop_32to8, mkexpr(oldRt));
21850 data = unop(Iop_32to16, mkexpr(oldRt));
22008 data = unop(Iop_32to8, mkexpr(oldRt));
22011 data = unop(Iop_32to16, mkexpr(oldRt));
22194 stmt( IRStmt_Exit( unop(Iop_32to1, mkexpr(kondT)),
22272 assign(delta, unop(Iop_16Uto32, loadLE(Ity_I16, ea)));
22274 assign(delta, unop(Iop_8Uto32, loadLE(Ity_I8, ea)));
22361 assign(dstT, unop(Iop_8Uto32,
22362 unop(Iop_32to8, mkexpr(rotT))));
22366 assign(dstT, unop(Iop_16Uto32,
22367 unop(Iop_32to16, mkexpr(rotT))));
22371 assign(dstT, unop(Iop_8Sto32,
22372 unop(Iop_32to8, mkexpr(rotT))));
22376 assign(dstT, unop(Iop_16Sto32,
22377 unop(Iop_32to16, mkexpr(rotT))));
22394 unop(Iop_8Sto32,
22395 unop(Iop_32to8, mkexpr(lo32))),
22398 unop(Iop_8Sto32,
22399 unop(Iop_32to8, mkexpr(hi32))),
22479 putIRegT( rDhi, unop(Iop_64HIto32, mkexpr(res)), condT );
22480 putIRegT( rDlo, unop(Iop_64to32, mkexpr(res)), condT );
22552 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
22553 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
22585 unop(Iop_32Uto64, mkexpr(argDhi))),
22586 unop(Iop_32Uto64, mkexpr(argDlo))) );
22587 assign( resHi, unop(Iop_64HIto32, mkexpr(res)) );
22588 assign( resLo, unop(Iop_64to32, mkexpr(res)) );
22607 = unop(Iop_64HIto32,
22629 = unop(Iop_64HIto32,
22721 unop(isU ? Iop_16Uto32 : Iop_16Sto32,
22722 unop(Iop_32to16,
22750 unop(isU ? Iop_8Uto32 : Iop_8Sto32,
22751 unop(Iop_32to8,
22774 unop(Iop_Clz32, mkexpr(arg))
22916 putIRegT(rT, unop(isH ? Iop_16Uto32 : Iop_8Uto32, mkexpr(res)),
22938 putIRegT(rT, unop(Iop_64to32, mkexpr(res)), IRTemp_INVALID);
22939 putIRegT(rT2, unop(Iop_64HIto32, mkexpr(res)), IRTemp_INVALID);
22967 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
22990 unop(isH ? Iop_32to16 : Iop_32to8,
22996 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
23026 unop(Iop_1Uto32, unop(Iop_Not1, mkexpr(resSC1))));
23214 IRExpr* data = unop(Iop_32to8, llGetIReg(rT));
23294 IRExpr* data = unop(Iop_32to16, llGetIReg(rT));
23687 assign(hi32, unop(Iop_64HIto32, mkexpr(v64)) );
23688 assign(lo32, unop(Iop_64to32, mkexpr(v64)) );
23782 assign(hi32, unop(Iop_64HIto32, mkexpr(v64)) );
23783 assign(lo32, unop(Iop_64to32, mkexpr(v64)) );
23909 return binop(Iop_32HLto64, unop(Iop_64to32, mkexpr(a10)),
23910 unop(Iop_64to32, mkexpr(b10)));
23916 return binop(Iop_32HLto64, unop(Iop_64HIto32, mkexpr(a10)),
23917 unop(Iop_64HIto32, mkexpr(b10)));
