Lines Matching refs:binop
280 static IRExpr* binop ( IROp op, IRExpr* a1, IRExpr* a2 )
318 //ZZ binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0))) );
350 //ZZ binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0))) );
435 //ZZ binop(Iop_Or32,
436 //ZZ binop(Iop_Shl32, mkexpr(src), mkU8(32 - rot)),
437 //ZZ binop(Iop_Shr32, mkexpr(src), mkU8(rot)));
442 //ZZ return binop(Iop_64HLtoV128, mkU64(i), mkU64(i));
450 //ZZ return binop(Iop_And32, e, mkU32(~3));
1011 assign(res, binop(mkOR(ty),
1012 binop(mkSHL(ty), mkexpr(arg), mkU8(w - imm)),
1013 binop(mkSHR(ty), mkexpr(arg), mkU8(imm)) ));
1031 assign(res, binop(mkSAR(ty),
1032 binop(mkSHL(ty), mkexpr(arg), mkU8(w - 1 - imm)),
1590 //ZZ IRExpr_ITE( binop(Iop_CmpNE32, mkexpr(guardT), mkU32(0)),
1630 //ZZ assign(nyu, binop(Iop_Or32, mkexpr(old), e) );
1661 binop(Iop_Shr32, IRExpr_Get(OFFB_FPCR, Ity_I32), mkU8(22)));
1664 binop(Iop_Or32,
1665 binop(Iop_And32,
1666 binop(Iop_Shl32, mkexpr(armEncd), mkU8(1)),
1668 binop(Iop_And32,
1669 binop(Iop_Shr32, mkexpr(armEncd), mkU8(1)),
1732 binop(Iop_Or64, IRExpr_Get(OFFB_CC_OP, Ity_I64), cond),
2046 binop(Iop_Or64,
2047 binop(Iop_Shr64,
2048 binop(Iop_And64,mkexpr(x),mkexpr(maskT)),
2050 binop(Iop_And64,
2051 binop(Iop_Shl64,mkexpr(x),mkU8(sh)),
2102 assign(t16, binop(Iop_Or64, mkexpr(src),
2103 binop(Iop_Shl64, mkexpr(src), mkU8(8))));
2105 assign(t32, binop(Iop_Or64, mkexpr(t16),
2106 binop(Iop_Shl64, mkexpr(t16), mkU8(16))));
2108 assign(t64, binop(Iop_Or64, mkexpr(t32),
2109 binop(Iop_Shl64, mkexpr(t32), mkU8(32))));
2114 assign(t32, binop(Iop_Or64, mkexpr(src),
2115 binop(Iop_Shl64, mkexpr(src), mkU8(16))));
2117 assign(t64, binop(Iop_Or64, mkexpr(t32),
2118 binop(Iop_Shl64, mkexpr(t32), mkU8(32))));
2123 assign(t64, binop
2124 binop(Iop_Shl64, mkexpr(src), mkU8(32))));
2141 assign(res, binop(Iop_64HLtoV128, mkexpr(i64), mkexpr(i64)));
2148 assign(i64b, binop(Iop_Or64, binop(Iop_Shl64, mkexpr(i64a), mkU8(32)),
2150 assign(res, binop(Iop_64HLtoV128, mkexpr(i64b), mkexpr(i64b)));
2154 assign(res, binop(Iop_64HLtoV128, mkexpr(src), mkexpr(src)));
2161 assign(res, binop(Iop_64HLtoV128, mkexpr(t2), mkexpr(t2)));
2237 binop(Iop_Or64,
2238 binop(Iop_And64,
2239 binop(Iop_Shr64, mkexpr(irRes), mkU8(5)),
2241 binop(Iop_And64, mkexpr(irRes), mkU64(1))));
2245 binop(Iop_Add64,
2246 binop(Iop_Shr64,
2247 binop(Iop_Sub64,
2248 binop(Iop_Shl64,
2249 binop(Iop_Xor64, mkexpr(ix), mkU64(1)),
2257 binop(Iop_And64,
2258 binop(Iop_And64,
2260 binop(Iop_Shr64, mkexpr(ix), mkU8(1))),
2263 assign(nzcv, binop(Iop_Sub64, mkexpr(termL), mkexpr(termR)));
2424 assign(res, binop(isSub ? Iop_Sub64 : Iop_Add64,
2442 assign(res, binop(isSub ? Iop_Sub32 : Iop_Add32,
2512 assign(res, binop(ops64[op], argL, argR));
2527 assign(res, binop(ops32[op], argL, argR));
2583 = binop(Iop_Or64,
2584 binop(Iop_And64, mkexpr(old), mkU64(~mask)),
2595 = binop(Iop_Or32,
2596 binop(Iop_And32, mkexpr(old), mkU32(~mask)),
2668 assign(bot, binop(mkOR(ty),
2669 binop(mkAND(ty), mkexpr(dst), mkU(ty, ~wmask)),
2670 binop(mkAND(ty), mkexpr(mathROR(ty, src, immR)),
2675 assign(res, binop(mkOR(ty),
2676 binop(mkAND(ty), mkexpr(top), mkU(ty, ~tmask)),
2677 binop(mkAND(ty), mkexpr(bot), mkU(ty, tmask))));
2713 assign(res, binop(mkOR(ty),
2714 binop(mkSHL(ty), mkexpr(srcHi), mkU8(szBits-imm6)),
2715 binop(mkSHR(ty), mkexpr(srcLo), mkU8(imm6))));
2766 assign(t1, binop(mkSHL(ty), mkexpr(t0), mkU8(sh_amt)));
2769 assign(t1, binop(mkSHR(ty), mkexpr(t0), mkU8(sh_amt)));
2772 assign(t1, binop(mkSAR(ty), mkexpr(t0), mkU8(sh_amt)));
2827 assign(res, binop(op, mkexpr(argL), mkexpr(argR)));
2879 binop(op,
2880 binop(op, mkexpr(argL), mkexpr(argR)),
2881 binop(xorOp, mkexpr(oldC), one)));
2884 binop(op,
2885 binop(op, mkexpr(argL), mkexpr(argR)),
2940 assign(res, binop(op, mkexpr(argL), mkexpr(argR)));
2975 binop(isU ? Iop_MullU64 : Iop_MullS64,
2998 binop(isAdd ? Iop_Add64 : Iop_Sub64,
3000 binop(Iop_Mul64, getIReg64orZR(mm), getIReg64orZR(nn))));
3004 binop(isAdd ? Iop_Add32 : Iop_Sub32,
3006 binop(Iop_Mul32, getIReg32orZR(mm), getIReg32orZR(nn))));
3039 argR = binop(mkADD(ty), argR, mkU(ty,1));
3045 argR = binop(mkSUB(ty), mkU(ty,0), argR);
3116 xMw = binop(Iop_And64, xMw, mkU64(0xFF)); break;
3118 xMw = binop(Iop_And64, xMw, mkU64(0xFFFF)); break;
3139 xMw = binop(Iop_Sar64, binop(Iop_Shl64, xMw, mkU8(shSX)),
3148 assign(argR, binop(Iop_Shl64, xMw, mkU8(imm3)));
3150 assign(res, binop(isSub ? Iop_Sub64 : Iop_Add64,
3319 assign(src, binop(Iop_Shl64, getIReg64orZR(nn), mkU8(32)));
3348 assign(src, binop(Iop_Shl64,
3355 binop(Iop_Xor64,
3356 binop(Iop_Shl64, mkexpr(src), one),
3357 binop(Iop_Shl64, binop(Iop_Shr64, mkexpr(src), one), one)));
3363 assign(dst, IRExpr_ITE(binop(Iop_CmpEQ64, mkexpr(srcZ), mkU64(0)),
3368 assign(dst, IRExpr_ITE(binop(Iop_CmpEQ64, mkexpr(srcZ), mkU64(0)),
3398 assign(srcR, binop(Iop_And64, getIReg64orZR(mm),
3408 assign(res, binop(iop, mkexpr(srcL),
3419 binop(Iop_CmpEQ64, mkexpr(srcR), mkU64(0)),
3421 binop(opOR,
3422 binop(opSHL,
3424 unop(Iop_64to8, binop(Iop_Sub64, width,
3426 binop(opSHR,
3452 putIRegOrZR(is64, dd, binop(is64 ? Iop_DivS64 : Iop_DivS32,
3456 putIRegOrZR(is64, dd, binop(is64 ? Iop_DivU64 : Iop_DivU32,
3490 assign(muld, binop(isU ? Iop_MullU32 : Iop_MullS32,
3492 assign(res, binop(isAdd ? Iop_Add64 : Iop_Sub64,
3521 binop(Iop_ShrV128,(_v128),mkU8(8*(_nbytes)))
3523 binop(Iop_ShlV128,(_v128),mkU8(8*(_nbytes)))
3525 binop(Iop_InterleaveLO64x2,(_argL),(_argR))
3527 binop(Iop_InterleaveHI64x2,(_argL),(_argR))
3529 binop(Iop_InterleaveLO32x4,(_argL),(_argR))
3531 binop(Iop_InterleaveHI32x4,(_argL),(_argR))
3533 binop(Iop_InterleaveLO16x8,(_argL),(_argR))
3535 binop(Iop_InterleaveHI16x8,(_argL),(_argR))
3537 binop(Iop_InterleaveLO8x16,(_argL),(_argR))
3539 binop(Iop_InterleaveHI8x16,(_argL),(_argR))
3541 binop(Iop_CatEvenLanes32x4,(_argL),(_argR))
3543 binop(Iop_CatOddLanes32x4,(_argL),(_argR))
3545 binop(Iop_CatOddLanes16x8,(_argL),(_argR))
3547 binop(Iop_CatOddLanes8x16,(_argL),(_argR))
3549 binop(Iop_CatEvenLanes8x16,(_argL),(_argR))
3551 binop(Iop_AndV128,(_arg1),(_arg2))
3553 binop(Iop_OrV128,(_arg1),(_arg2))
3555 binop(Iop_OrV128,(_arg1),binop(Iop_OrV128,(_arg2),(_arg3)))
3557 binop(Iop_OrV128, \
3558 binop(Iop_OrV128,(_arg1),(_arg2)), \
3559 binop(Iop_OrV128,(_arg3),(_arg4)))
3582 assign(*i0, binop(Iop_InterleaveLO64x2, mkexpr(u1), mkexpr(u0)));
3583 assign(*i1, binop(Iop_InterleaveHI64x2, mkexpr(u1), mkexpr(u0)));
3590 assign(*i0, binop(Iop_InterleaveLO32x4, mkexpr(u1), mkexpr(u0)));
3591 assign(*i1, binop(Iop_InterleaveHI32x4, mkexpr(u1), mkexpr(u0)));
3599 assign(*i0, binop(Iop_InterleaveLO16x8, mkexpr(u1), mkexpr(u0)));
3600 assign(*i1, binop(Iop_InterleaveHI16x8, mkexpr(u1), mkexpr(u0)));
3608 assign(*i0, binop(Iop_InterleaveLO8x16, mkexpr(u1), mkexpr(u0)));
3609 assign(*i1, binop(Iop_InterleaveHI8x16, mkexpr(u1), mkexpr(u0)));
3897 assign(*u0, binop(Iop_InterleaveLO64x2, mkexpr(i1), mkexpr(i0)));
3898 assign(*u1, binop(Iop_InterleaveHI64x2, mkexpr(i1), mkexpr(i0)));
3905 assign(*u0, binop(Iop_CatEvenLanes32x4, mkexpr(i1), mkexpr(i0)));
3906 assign(*u1, binop(Iop_CatOddLanes32x4, mkexpr(i1), mkexpr(i0)));
3914 assign(*u0, binop(Iop_CatEvenLanes16x8, mkexpr(i1), mkexpr(i0)));
3915 assign(*u1, binop(Iop_CatOddLanes16x8, mkexpr(i1), mkexpr(i0)));
3923 assign(*u0, binop(Iop_CatEvenLanes8x16, mkexpr(i1), mkexpr(i0)));
3924 binop(Iop_CatOddLanes8x16, mkexpr(i1), mkexpr(i0)));
4225 assign(du0, binop(doubler, EX(u0), EX(u0)));
4226 assign(du1, binop(doubler, EX(u1), EX(u1)));
4230 assign(*i0, binop(halver, EX(di0), EX(di0)));
4231 assign(*i1, binop(halver, EX(di1), EX(di1)));
4257 assign(du0, binop(doubler, EX(u0), EX(u0)));
4258 assign(du1, binop(doubler, EX(u1), EX(u1)));
4259 assign(du2, binop(doubler, EX(u2), EX(u2)));
4264 assign(*i0, binop(halver, EX(di0), EX(di0)));
4265 assign(*i1, binop(halver, EX(di1), EX(di1)));
4266 assign(*i2, binop(halver, EX(di2), EX(di2)));
4294 assign(du0, binop(doubler, EX(u0), EX(u0)));
4295 assign(du1, binop(doubler, EX(u1), EX(u1)));
4296 assign(du2, binop(doubler, EX(u2), EX(u2)));
4297 assign(du3, binop(doubler, EX(u3), EX(u3)));
4304 assign(*i0, binop(halver, EX(di0), EX(di0)));
4305 assign(*i1, binop(halver, EX(di1), EX(di1)));
4306 assign(*i2, binop(halver, EX(di2), EX(di2)));
4307 assign(*i3, binop(halver, EX(di3), EX(di3)));
4338 assign(di0, binop(doubler, EX(i0), EX(i0)));
4339 assign(di1, binop(doubler, EX(i1), EX(i1)));
4344 assign(*u0, binop(halver, EX(du0), EX(du0)));
4345 assign(*u1, binop(halver, EX(du1), EX(du1)));
4371 assign(di0, binop(doubler, EX(i0), EX(i0)));
4372 assign(di1, binop(doubler, EX(i1), EX(i1)));
4373 assign(di2, binop(doubler, EX(i2), EX(i2)));
4378 assign(*u0, binop(halver, EX(du0), EX(du0)));
4379 assign(*u1, binop(halver, EX(du1), EX(du1)));
4380 assign(*u2, binop(halver, EX(du2), EX(du2)));
4408 assign(di0, binop(doubler, EX(i0), EX(i0)));
4409 assign(di1, binop(doubler, EX(i1), EX(i1)));
4410 assign(di2, binop(doubler, EX(i2), EX(i2)));
4411 assign(di3, binop(doubler, EX(i3), EX(i3)));
4418 assign(*u0, binop(halver, EX(du0), EX(du0)));
4419 assign(*u1, binop(halver, EX(du1), EX(du1)));
4420 assign(*u2, binop(halver, EX(du2), EX(du2)));
4421 assign(*u3, binop(halver, EX(du3), EX(du3)));
4528 rhs = binop(Iop_Shl64, getIReg64orZR(mm), mkU8(szLg2));
4538 rhs = binop(Iop_Shl64,
4549 rhs = binop(Iop_Shl64,
4561 assign(res, binop(Iop_Add64, getIReg64orSP(nn), rhs));
4664 assign(ta, binop(Iop_Add64, getIReg64orSP(nn), mkU64(offs)));
4726 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm9)));
4830 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm7)));
4866 binop(Iop_Add64,mkexpr(tTA),mkU64(0))));
4868 binop(Iop_Add64,mkexpr(tTA),mkU64(8))));
4872 binop(Iop_Add64,mkexpr(tTA),mkU64(0))));
4874 binop(Iop_Add64,mkexpr(tTA),mkU64(4))));
4877 storeLE(binop(Iop_Add64,mkexpr(tTA),mkU64(0)),
4879 storeLE(binop(Iop_Add64,mkexpr(tTA),mkU64(8)),
4884 storeLE(binop(Iop_Add64,mkexpr(tTA),mkU64(0)),
4886 storeLE(binop(Iop_Add64,mkexpr(tTA),mkU64(4)),
5029 IRExpr* ea = binop(Iop_Add64,
5104 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm9)));
5180 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm9)));
5267 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm7)));
5316 loadLE(ty, binop(Iop_Add64, mkexpr(tTA), mkU64(0))));
5321 loadLE(ty, binop(Iop_Add64, mkexpr(tTA), mkU64(szB))));
5323 storeLE(binop(Iop_Add64, mkexpr(tTA), mkU64(0)),
5325 storeLE(binop(Iop_Add64, mkexpr(tTA), mkU64(szB)),
5515 assign(tEA, binop(Iop_Add64, getIReg64orSP(nn), mkU64(pimm12)));
5565 assign(tEA, binop(Iop_Add64, mkexpr(tRN), mkU64(simm9)));
5607 assign(tEA, binop(Iop_Add64, getIReg64orSP(nn), mkU64(simm9)));
5702 assign(tWB, binop(Iop_Add64,
5748 case 4: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(3*step)),
5751 case 3: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(2*step)),
5754 case 2: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(1*step)),
5757 case 1: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(0*step)),
5775 binop(Iop_Add64, mkexpr(tTA),
5781 binop(Iop_Add64, mkexpr(tTA),
5787 binop(Iop_Add64, mkexpr(tTA),
5793 binop(Iop_Add64, mkexpr(tTA),
5913 assign(tWB, binop(Iop_Add64,
5944 case 4: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(3*step)),
5947 case 3: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(2*step)),
5950 case 2: storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(1*step)),
5952 storeLE( binop(Iop_Add64, mkexpr(tTA), mkU64(0*step)),
5970 binop(Iop_Add64, mkexpr(tTA),
5976 binop(Iop_Add64, mkexpr(tTA),
5982 binop(Iop_Add64, mkexpr(tTA),
5986 binop(Iop_Add64, mkexpr(tTA),
6081 assign(tWB, binop(Iop_Add64,
6097 assign(e3, loadLE(ty, binop(Iop_Add64, mkexpr(tTA),
6104 assign(e2, loadLE(ty, binop(Iop_Add64, mkexpr(tTA),
6111 assign(e1, loadLE(ty, binop(Iop_Add64, mkexpr(tTA),
6118 assign(e0, loadLE(ty, binop(Iop_Add64, mkexpr(tTA),
6227 assign(tWB, binop(Iop_Add64,
6241 = binop(Iop_Add64, mkexpr(tTA), mkU64(3 * laneSzB));
6251 = binop(Iop_Add64, mkexpr(tTA), mkU64(2 * laneSzB));
6261 = binop(Iop_Add64, mkexpr(tTA), mkU64(1 * laneSzB));
6271 = binop(Iop_Add64, mkexpr(tTA), mkU64(0 * laneSzB));
6349 putIReg64orZR(ss, binop(Iop_Xor64, unop(Iop_1Uto64, mkexpr(res)),
6409 assign(ea, binop(Iop_Add64, getIReg64orSP(nn), mkU64(imm12 * 8)));
6521 cond = binop(bIfZ ? Iop_CmpEQ64 : Iop_CmpNE64,
6524 cond = binop
6555 = binop(bIfZ ? Iop_CmpEQ64 : Iop_CmpNE64,
6556 binop(Iop_And64,
6557 binop(Iop_Shr64, getIReg64orZR(tt), mkU8(bitNo)),
6635 assign(qc64, binop(Iop_And64,
6636 binop(Iop_Shr64, getIReg64orZR(tt), mkU8(27)),
6638 IRExpr* qcV128 = binop(Iop_64HLtoV128, mkexpr(qc64), mkexpr(qc64));
6647 assign(qc64, binop(Iop_Or64, unop(Iop_V128HIto64, mkexpr(qcV128)),
6649 IRExpr* res = binop(Iop_Shl64,
6651 binop(Iop_CmpNE64, mkexpr(qc64), mkU64(0))),
6671 assign(t, binop(Iop_And64, getIReg64orZR(tt), mkU64(0xF0000000ULL)));
6755 assign( addr, binop( Iop_And64,
6786 assign( addr, binop( Iop_And64,
6861 return binop(Iop_InterleaveLO64x2, mkexpr(a10), mkexpr(b10));
6866 return binop(Iop_InterleaveHI64x2, mkexpr(a10), mkexpr(b10));
6871 return binop(Iop_CatEvenLanes32x4, mkexpr(a3210), mkexpr(b3210));
6876 return binop(Iop_CatOddLanes32x4, mkexpr(a3210), mkexpr(b3210));
6881 return binop(Iop_InterleaveLO32x4, mkexpr(a3210), mkexpr(b3210));
6886 return binop(Iop_InterleaveHI32x4, mkexpr(a3210), mkexpr(b3210));
6891 return binop(Iop_CatEvenLanes16x8, mkexpr(a76543210), mkexpr(b76543210));
6896 return binop(Iop_CatOddLanes16x8, mkexpr(a76543210), mkexpr(b76543210));
6901 return binop(Iop_InterleaveLO16x8, mkexpr(a76543210), mkexpr(b76543210));
6906 return binop(Iop_InterleaveHI16x8, mkexpr(a76543210), mkexpr(b76543210));
6912 return binop(Iop_CatEvenLanes8x16, mkexpr(aFEDCBA9876543210),
6919 return binop(Iop_CatOddLanes8x16, mkexpr(aFEDCBA9876543210),
6926 return binop(Iop_InterleaveLO8x16, mkexpr(aFEDCBA9876543210),
6933 return binop(Iop_InterleaveHI8x16, mkexpr(aFEDCBA9876543210),
7227 assign(maxFE, binop(op, mkexpr(xAllF), mkexpr(xAllE)));
7228 assign(maxDC, binop(op, mkexpr(xAllD), mkexpr(xAllC)));
7229 assign(maxBA, binop(op, mkexpr(xAllB), mkexpr(xAllA)));
7230 assign(max98, binop(op, mkexpr(xAll9), mkexpr(xAll8)));
7231 assign(max76, binop(op, mkexpr(xAll7), mkexpr(xAll6)));
7232 assign(max54, binop(op, mkexpr(xAll5), mkexpr(xAll4)));
7233 assign(max32, binop(op, mkexpr(xAll3), mkexpr(xAll2)));
7234 assign(max10, binop(op, mkexpr(xAll1), mkexpr(xAll0)));
7239 assign(maxFEDC, binop(op, mkexpr(maxFE), mkexpr(maxDC)));
7240 assign(maxBA98, binop(op, mkexpr(maxBA), mkexpr(max98)));
7241 assign(max7654, binop(op, mkexpr(max76), mkexpr(max54)));
7242 assign(max3210, binop(op, mkexpr(max32), mkexpr(max10)));
7245 assign(maxFEDCBA98, binop(op, mkexpr(maxFEDC), mkexpr(maxBA98)));
7246 assign(max76543210, binop(op, mkexpr(max7654), mkexpr(max3210)));
7248 assign(maxAllLanes, binop(op, mkexpr(maxFEDCBA98),
7289 assign(max76, binop(op, mkexpr(x77777777), mkexpr(x66666666)));
7290 assign(max54, binop(op, mkexpr(x55555555), mkexpr(x44444444)));
7291 assign(max32, binop(op, mkexpr(x33333333), mkexpr(x22222222)));
7292 assign(max10, binop(op, mkexpr(x11111111), mkexpr(x00000000)));
7295 assign(max7654, binop(op, mkexpr(max76), mkexpr(max54)));
7296 assign(max3210, binop(op, mkexpr(max32), mkexpr(max10)));
7298 assign(max76543210, binop(op, mkexpr(max7654), mkexpr(max3210)));
7321 assign(max32, binop(op, mkexpr(x3333), mkexpr(x2222)));
7322 assign(max10, binop(op, mkexpr(x1111), mkexpr(x0000)));
7324 assign(max3210, binop(op, mkexpr(max32), mkexpr(max10)));
7333 assign(x11, binop(Iop_InterleaveHI64x2, mkexpr(x10), mkexpr(x10)));
7334 assign(x00, binop(Iop_InterleaveLO64x2, mkexpr(x10), mkexpr(x10)));
7336 assign(max10, binop(op, mkexpr(x11), mkexpr(x00)));
7365 assign(all15, binop(Iop_64HLtoV128, mkexpr(half15), mkexpr(half15)));
7368 assign(all16, binop(Iop_64HLtoV128, mkexpr(half16), mkexpr(half16)));
7371 assign(all32, binop(Iop_Add8x16, mkexpr(all16), mkexpr(all16)));
7374 assign(all48, binop(Iop_Add8x16, mkexpr(all16), mkexpr(all32)));
7377 assign(all64, binop(Iop_Add8x16, mkexpr(all32), mkexpr(all32)));
7396 binop(Iop_Sub8x16, mkexpr(src), mkexpr(bias)));
7399 binop(Iop_CmpGT8Ux16, mkexpr(all16), mkexpr(biased_indices)));
7402 binop(Iop_AndV128, mkexpr(biased_indices), mkexpr(all15)));
7405 binop(Iop_Perm8x16, mkexpr(tab[tabent]),
7409 binop(Iop_AndV128, mkexpr(results_or_junk), mkexpr(valid_mask)));
7412 assign(tmp, binop(Iop_OrV128, mkexpr(results_or_zero),
7425 binop(Iop_CmpGT8Ux16, mkexpr(allXX[len]), mkexpr(src)));
7428 binop(Iop_OrV128,
7430 binop(Iop_AndV128,
7449 assign(res, binop(opI64x2toV128, unop(slice, argL),
7466 assign(msk, binop(isU ? mkVecCMPGTU(size) : mkVecCMPGTS(size),
7469 binop(Iop_OrV128,
7470 binop(Iop_AndV128,
7471 binop(mkVecSUB(size), mkexpr(argL), mkexpr(argR)),
7473 binop(Iop_AndV128,
7474 binop(mkVecSUB(size), mkexpr(argR), mkexpr(argL)),
7493 binop(zWiden ? Iop_ShrN64x2 : Iop_SarN64x2,
7494 binop(fromUpperHalf ? Iop_InterleaveHI32x4
7502 binop(zWiden ? Iop_ShrN32x4 : Iop_SarN32x4,
7503 binop(fromUpperHalf ? Iop_InterleaveHI16x8
7511 binop(zWiden ? Iop_ShrN16x8 : Iop_SarN16x8,
7512 binop(fromUpperHalf ? Iop_InterleaveHI8x16
7547 assign(res, binop(opSxR, mkexpr(src), mkU8(amt)));
7549 assign(res, binop(opSxR, binop(opSHL, mkexpr(src), mkU8(amt)),
7562 assign(res, binop(mkVecCATEVENLANES(sizeNarrow),
7605 assign(tmp, binop(ops[i], mkexpr(res), mkexpr(res)));
7709 assign(t_newHI_zero, binop(Iop_InterleaveLO64x2, mkexpr(new64),
7712 assign(res, binop(Iop_OrV128, mkexpr(t_zero_oldLO),
7732 assign(mask, binop(mkVecCMPGTS(size), mkV128(0x0000), mkexpr(src)));
7734 assign(nsub, binop(mkVecSUB(size), mkV128(0x0000), mkexpr(src)));
7735 assign(qsub, binop(mkVecQSUBS(size), mkV128(0x0000), mkexpr(src)));
7736 assign(*nabs, binop(Iop_OrV128,
7737 binop(Iop_AndV128, mkexpr(nsub), mkexpr(mask)),
7738 binop(Iop_AndV128, mkexpr(src), mkexpr(maskn))));
7739 assign(*qabs, binop(Iop_OrV128,
7740 binop(Iop_AndV128, mkexpr(qsub), mkexpr(mask)),
7741 binop(Iop_AndV128, mkexpr(src), mkexpr(maskn))));
7754 assign(*nneg, binop(mkVecSUB(size), mkV128(0x0000), mkexpr(src)));
7755 assign(*qneg, binop(mkVecQSUBS(size), mkV128(0x0000), mkexpr(src)));
7799 : binop(accOp, mkexpr(vecD), mkexpr(mul)));
7835 assign(*sat1n, binop(mkVecADD(size+1), mkexpr(tn), mkexpr(tn)));
7850 assign(*sat2q, binop(mas == 'a' ? mkVecQADDS(size+1) : mkVecQSUBS(size+1),
7852 assign(*sat2n, binop(mas == 'a' ? mkVecADD(size+1) : mkVecSUB(size+1),
7876 assign(*resHI, binop(opMulls, mkexpr(argLhi), mkexpr(argRhi)));
7877 assign(*resLO, binop(opMulls, mkexpr(argLlo), mkexpr(argRlo)));
7899 assign(*sat1q, binop(mkVecQRDMULHIS(size), mkexpr(vN), mkexpr(vM)));
7904 binop(mkVecCATODDLANES(size),
7905 binop(addWide,
7906 binop(addWide, mkexpr(mullsHI), mkexpr(mullsHI)),
7908 binop(addWide,
7909 binop(addWide, mkexpr(mullsLO), mkexpr(mullsLO)),
7912 assign(*sat1q, binop(mkVecQDMULHIS(size), mkexpr(vN), mkexpr(vM)));
7915 binop(mkVecCATODDLANES(size),
7916 binop(addWide, mkexpr(mullsHI), mkexpr(mullsHI)),
7917 binop(addWide, mkexpr(mullsLO), mkexpr(mullsLO))));
7943 assign(*res, binop(qop, mkexpr(src), mkU8(shift)));
7954 assign(*qDiff1, binop(mkVecSHRN(size), mkexpr(src), mkU8(rshift)));
7963 assign(*res, binop(qop, mkexpr(src), mkU8(shift)));
7975 assign(*qDiff1, binop(mkVecSHRN(size), mkexpr(src), mkU8(rshift)));
7978 assign(*qDiff2, binop(mkVecSHRN(size),
7979 binop(mkVecSARN(size), mkexpr(src),
7991 assign(*res, binop(qop, mkexpr(src), mkU8(shift)));
7995 assign(*qDiff1, binop(mkVecSHRN(size), mkexpr(src), mkU8(laneBits-1)));
8003 assign(*qDiff1, binop(mkVecSHRN(size), mkexpr(src), mkU8(rshift)));
8030 assign(vecOne, binop(Iop_64HLtoV128, mkexpr(imm64), mkexpr(imm64)));
8035 binop(opADD,
8036 binop(opSHR, mkexpr(aa), mkexpr(scaOne)),
8037 binop(opADD,
8038 binop(opSHR, mkexpr(bb), mkexpr(scaOne)),
8039 binop(opSHR,
8040 binop(opADD,
8041 binop(opADD,
8042 binop(Iop_AndV128, mkexpr(aa),
8044 binop(Iop_AndV128, mkexpr(bb),
8073 assign(diff, binop(Iop_XorV128, mkexpr(qres), mkexpr(nres)));
8077 assign(diff, unop(opZHI, binop(Iop_XorV128, mkexpr(qres), mkexpr(nres))));
8080 assign(newQCFLAG, binop(Iop_OrV128, mkexpr(oldQCFLAG), mkexpr(diff)));
8122 assign(*rearrL, binop(Iop_InterleaveHI64x2, mkexpr(vecM), mkexpr(vecN)));
8123 assign(*rearrR, binop(Iop_InterleaveLO64x2, mkexpr(vecM), mkexpr(vecN)));
8127 assign(*rearrL, binop(Iop_CatOddLanes32x4, mkexpr(vecM), mkexpr(vecN)));
8128 assign(*rearrR, binop(Iop_CatEvenLanes32x4, mkexpr(vecM), mkexpr(vecN)));
8134 assign(m1n1m0n0, binop(Iop_InterleaveLO32x4,
8212 assign(hi64lo64, binop(Iop_InterleaveLO64x2,
8320 assign(preL, binop(Iop_InterleaveLO64x2, getQReg128(mm),
8327 assign(res, binop(op, mkexpr(preL), mkexpr(preR)));
8349 assign(res, binop(op2, binop(op1, mkexpr(srcM), mkexpr(srcM)),
8350 binop(op1, mkexpr(srcN), mkexpr(srcN))));
8383 assign(res, binop(op, mkexpr(preL), mkexpr(preR)));
8434 = binop(mkVecADD(size+1),
8622 putQReg128(dd, binop(Iop_64HLtoV128,
8948 = binop(Iop_64HLtoV128, mkU64(inv ^ imm64lo), mkU64(inv ^ imm64lo));
8950 = binop(isORR ? Iop_OrV128 : Iop_AndV128, getQReg128(dd), immV128);
8964 IRExpr* immV128 = binop(Iop_64HLtoV128, mkU64(imm64hi),
9033 putQReg128(dd, binop(Iop_64HLtoV128, mkU64(0), mkexpr(w0)));
9071 assign(xx, binop(Iop_InterleaveHI64x2, mkexpr(xy), mkexpr(xy)));
9073 binop(Iop_Add64x2, mkexpr(xy), mkexpr(xx))));
9118 binop(opMXX, mkexpr(argL), mkexpr(argR))));
9172 assign(shf, binop(op, src, mkU8(sh - nudge)));
9174 assign(res, isAcc ? binop(Iop_Add64x2, getQReg128(dd), mkexpr(shf))
9201 assign(shf, binop(op, src, amt));
9202 assign(res, isAcc ? binop(Iop_Add64x2, getQReg128(dd), mkexpr(shf))
9220 IRExpr* nmaskV = binop(Iop_64HLtoV128, mkU64(nmask), mkU64(nmask));
9222 assign(res, binop(Iop_OrV128,
9223 binop(Iop_AndV128, getQReg128(dd), nmaskV),
9224 binop(Iop_ShrN64x2, getQReg128(nn), mkU8(sh))));
9238 : binop(Iop_ShlN64x2, getQReg128(nn), mkU8(sh))));
9252 IRExpr* nmaskV = binop(Iop_64HLtoV128, mkU64(nmask), mkU64(nmask));
9254 assign(res, binop(Iop_OrV128,
9255 binop(Iop_AndV128, getQReg128(dd), nmaskV),
9256 binop(Iop_ShlN64x2, getQReg128(nn), mkU8(sh))));
9338 assign(pair, binop(op, mkexpr(src128), mkU8(shift)));
9345 assign(q64q64, binop(Iop_InterleaveHI64x2, mkexpr(pair), mkexpr(pair)));
9382 binop(opCVT, mkexpr(rm), mkexpr(src)), scaleE));
9420 assign(res, binop(opCVT, mkexpr(rm),
9553 size, binop(qop, mkexpr(argL), mkexpr(argR)))));
9555 size, binop(nop, mkexpr(argL), mkexpr(argR)))));
9573 isGT ? binop(Iop_CmpGT64Sx2, argL, argR)
9574 : binop(Iop_CmpGT64Ux2, argL, argR));
9590 isGE ? unop(Iop_NotV128, binop(Iop_CmpGT64Sx2, argR, argL))
9591 : unop(Iop_NotV128, binop(Iop_CmpGT64Ux2, argR, argL)));
9610 assign(res, binop(op, getQReg128(nn), getQReg128(mm)));
9640 binop(op,
9660 assign(res, binop(isSUB ? Iop_Sub64 : Iop_Add64,
9679 isEQ ? binop(Iop_CmpEQ64x2, argL, argR)
9680 : unop(Iop_NotV128, binop(Iop_CmpEQ64x2,
9681 binop(Iop_AndV128, argL, argR),
9751 assign(res, isGE ? binop(opCMP, getQReg128(mm), getQReg128(nn)) // swapd
9752 : binop(opCMP, getQReg128(nn), getQReg128(mm)));
9766 assign(res, binop(opCMP, getQReg128(mm), getQReg128(nn))); // swapd
9784 assign(res, binop(opCMP, unop(opABS, getQReg128(mm)),
9801 assign(res, binop(op, getQReg128(nn), getQReg128(mm)));
9851 size, binop(qop, mkexpr(argL), mkexpr(argR)));
9853 size, binop(nop, mkexpr(argL), mkexpr(argR)));
9884 assign(res, isGT ? binop(Iop_CmpGT64Sx2, argL, argR)
9885 : unop(Iop_NotV128, binop(Iop_CmpGT64Sx2, argR, argL)));
9898 assign(res, isEQ ? binop(Iop_CmpEQ64x2, argL, argR)
9900 binop(Iop_CmpGT64Sx2, argL, argR)));
9909 binop(Iop_CmpGT64Sx2, mkV128(0x0000),
9926 binop(Iop_Sub64x2, mkV128(0x0000), getQReg128(nn))));
9964 assign(res, swap ? binop(opCmp, zero, getQReg128(nn))
9965 : binop(opCmp, getQReg128(nn), zero));
10015 binop(Iop_F64toF32, mkU32(Irrm_NEAREST),
10063 assign(res, binop(cvt, mkU32(irrm), mkexpr(src)));
10084 putQRegLO(dd, binop(iop, mkexpr(rm), getQRegLO(nn, tyI)));
10117 assign(res, binop(op, mkexpr(rm), getQRegLane(nn, 0, ty)));
10368 assign(shf, binop(op, src, mkU8(shift - nudge)));
10370 assign(res, isAcc ? binop(mkVecADD(size), getQReg128(dd), mkexpr(shf))
10412 assign(shf, binop(op, src, amt));
10413 assign(res, isAcc ? binop(mkVecADD(size), getQReg128(dd), mkexpr(shf))
10448 assign(res, binop(mkVecSHRN(size), src, mkU8(shift)));
10449 IRExpr* nmask = binop(mkVecSHLN(size),
10452 assign(tmp, binop(Iop_OrV128,
10454 binop(Iop_AndV128, getQReg128(dd), nmask)));
10494 assign(res, binop(op, src, mkU8(shift)));
10496 IRExpr* nmask = binop(mkVecSHRN(size),
10499 assign(tmp, binop(Iop_OrV128,
10501 binop(Iop_AndV128, getQReg128(dd), nmask)));
10567 assign(t2, isR ? binop(mkVecADD(size+1),
10571 assign(t3, binop(mkVecSHRN(size+1), mkexpr(t2), mkU8(shift)));
10622 assign(pair, binop(op, mkexpr(src128), mkU8(shift)));
10629 assign(q64q64, binop(Iop_InterleaveHI64x2, mkexpr(pair), mkexpr(pair)));
10675 res = binop(isU ? Iop_ShrN64x2 : Iop_SarN64x2, tmp, mkU8(32-sh));
10684 res = binop(isU ? Iop_ShrN32x4 : Iop_SarN32x4, tmp, mkU8(16-sh));
10693 res = binop(isU ? Iop_ShrN16x8 : Iop_SarN16x8, tmp, mkU8(8-sh));
10742 binop(opCVT, mkexpr(rm), mkexpr(src)),
10788 assign(res, binop(opCVT, mkexpr(rm),
10845 assign(res, binop(isADD ? mkVecADD(size+1) : mkVecSUB(size+1),
10870 assign(res, binop(isADD ? mkVecADD(size+1) : mkVecSUB(size+1),
10896 IRExpr* wideE = binop(isADD ? mkVecADD(size+1) : mkVecSUB(size+1),
10899 wideE = binop(mkVecADD(size+1),
10907 assign(shrd, binop(mkVecSHRN(size+1), mkexpr(wide), mkU8(shift[size])));
10910 assign(new64, binop(mkVecCATEVENLANES(size), mkexpr(shrd), mkexpr(shrd)));
10936 assign(res, isACC ? binop(mkVecADD(size+1), mkexpr(abd), getQReg128(dd))
11100 assign(resHi, binop(opSxR,
11101 binop(opADDSUB, mkexpr(argLhi), mkexpr(argRhi)),
11103 assign(resLo, binop(opSxR,
11104 binop(opADDSUB, mkexpr(argLlo), mkexpr(argRlo)),
11157 bitQ, binop(qop, mkexpr(argL), mkexpr(argR))));
11159 bitQ, binop(nop, mkexpr(argL), mkexpr(argR))));
11178 assign(res, binop(isORx ? Iop_OrV128 : Iop_AndV128,
11207 assign(res, binop(opXOR, mkexpr(argM), mkexpr(argN)));
11210 assign(res, binop(opXOR, mkexpr(argM),
11211 binop(opAND,
11212 binop(opXOR, mkexpr(argM), mkexpr(argN)),
11216 assign(res, binop(opXOR, mkexpr(argD),
11217 binop(opAND,
11218 binop(opXOR, mkexpr(argD), mkexpr(argN)),
11222 assign(res, binop(opXOR, mkexpr(argD),
11223 binop(opAND,
11224 binop(opXOR, mkexpr(argD), mkexpr(argN)),
11247 isGT ? binop(mkVecCMPGTS(size), argL, argR)
11248 : binop(mkVecCMPGTU(size), argL, argR));
11266 isGE ? unop(Iop_NotV128, binop(mkVecCMPGTS(size), argR, argL))
11267 : unop(Iop_NotV128, binop(mkVecCMPGTU(size), argR, argL)));
11287 assign(res, binop(op, getQReg128(nn), getQReg128(mm)));
11318 assign(res256, binop(op,
11345 assign(t, binop(op, getQReg128(nn), getQReg128(mm)));
11366 assign(t2, isACC ? binop(mkVecADD(size), mkexpr(t1), getQReg128(dd))
11384 assign(t, binop(op, getQReg128(nn), getQReg128(mm)));
11402 isEQ ? binop(mkVecCMPEQ(size), argL, argR)
11403 : unop(Iop_NotV128, binop(mkVecCMPEQ(size),
11404 binop(Iop_AndV128, argL, argR),
11423 assign(res, binop(opADDSUB,
11425 binop(opMUL, getQReg128(nn), getQReg128(mm))));
11445 assign(res, binop(opMUL, getQReg128(nn), getQReg128(mm)));
11471 binop(op,
11472 binop(mkVecCATEVENLANES(size), mkexpr(vM), mkexpr(vN)),
11473 binop(mkVecCATODDLANES(size), mkexpr(vM), mkexpr(vN))));
11478 binop(Iop_CatEvenLanes32x4, mkexpr(res128),
11520 binop(mkVecADD(size),
11521 binop(mkVecCATEVENLANES(size), mkexpr(vM), mkexpr(vN)),
11522 binop(mkVecCATODDLANES(size), mkexpr(vM), mkexpr(vN))));
11527 binop(Iop_CatEvenLanes32x4, mkexpr(res128),
11550 assign(res, binop(opMXX, getQReg128(nn), getQReg128(mm)));
11650 assign(t1, isGE ? binop(opCMP, getQReg128(mm), getQReg128(nn)) // swapd
11651 : binop(opCMP, getQReg128(nn), getQReg128(mm)));
11665 assign(t1, binop(opCMP, getQReg128(mm), getQReg128(nn))); // swapd
11683 assign(t1, binop(opCMP, unop(opABS, getQReg128(mm)),
11715 binop(opMXX, mkexpr(preL), mkexpr(preR))));
11775 assign(res, binop(op, getQReg128(nn), getQReg128(mm)));
11865 binop(mkVecADD(size+1),
11870 assign(res, isACC ? binop(mkVecADD(size+1), mkexpr(sum), getQReg128(dd))
11903 bitQ, binop(qop, mkexpr(argL), mkexpr(argR))));
11905 bitQ, binop(nop, mkexpr(argL), mkexpr(argR))));
11982 assign(res, isGT ? binop(opGTS, argL, argR)
11983 : unop(Iop_NotV128, binop(opGTS, argR, argL)));
11999 assign(res, isEQ ? binop(mkVecCMPEQ(size), argL, argR)
12001 binop(mkVecCMPGTS(size), argL, argR)));
12015 assign(res, binop(mkVecCMPGTS(size), argR, argL));
12038 assign(res, binop(mkVecSUB(size), mkV128(0x0000), getQReg128(nn)));
12078 assign(res, swap ? binop(opCmp, zero, getQReg128(nn))
12079 : binop(opCmp, getQReg128(nn), zero));
12166 assign(res, binop(opSHL, binop(opINT, mkexpr(src), mkexpr(src)),
12189 binop(opCvt, mkexpr(rm), mkexpr(src[i])));
12214 binop(opCvt, mkU32(Irrm_NEAREST), mkexpr(src[i])));
12295 putQRegLane(dd, i, binop(opRND, mkexpr(irrm),
12301 putQRegLane(dd, i, binop(opRND, mkexpr(irrm),
12352 putQRegLane(dd, i, binop(cvt, mkU32(irrm),
12358 putQRegLane(dd, i, binop(cvt, mkU32(irrm),
12411 binop(iop, mkexpr(rm), getQRegLane(nn, i, tyI)));
12446 assign(resV, binop(op, mkexpr(mk_get_IR_rounding_mode()),
12583 IRExpr* prod = binop(opMUL, mkexpr(vecN), mkexpr(vecM));
12585 assign(res, binop
12835 assign(irRes, binop(isD ? Iop_CmpF64 : Iop_CmpF32,
12839 assign(nzcv_28x0, binop(Iop_Shl64, mkexpr(nzcv), mkU8(28)));
12893 assign(irRes, binop(isD ? Iop_CmpF64 : Iop_CmpF32,
12900 assign(nzcvT_28x0, binop(Iop_Shl64, mkexpr(nzcvT), mkU8(28)));
12997 assign(res, binop(mkSQRTF(ity),
13051 assign(res, binop(dstIsH ? Iop_F64toF16 : Iop_F64toF32,
13067 assign(res, binop(Iop_F32toF16,
13138 assign(dst, binop(isD ? Iop_RoundF64toInt : Iop_RoundF32toInt,
13205 binop(iop, getQReg128(nn), getQReg128(mm))));
13401 IRExpr* res = binop(ops[ix], mkexpr(irrm),
13451 : binop(ops[ix],
13599 assign(dst, binop(iop, mkU32(irrm), mkexpr(src)));
13633 : binop(ops[ix],
