Lines Matching refs:mkexpr
616 static IRExpr* mkexpr ( IRTemp tmp )
694 assign( *vOdd, binop(Iop_MullEven8Ux16, mkexpr(ones8x16), vIn) );
695 assign( *vEvn, binop(Iop_MullEven8Ux16, mkexpr(ones8x16),
712 assign( *vOdd, binop(Iop_MullEven8Sx16, mkexpr(ones8x16), vIn) );
713 assign( *vEvn, binop(Iop_MullEven8Sx16, mkexpr(ones8x16),
730 assign( *vOdd, binop(Iop_MullEven16Ux8, mkexpr(ones16x8), vIn) );
731 assign( *vEvn, binop(Iop_MullEven16Ux8, mkexpr(ones16x8),
748 assign( *vOdd, binop(Iop_MullEven16Sx8, mkexpr(ones16x8), vIn) );
749 assign( *vEvn, binop(Iop_MullEven16Sx8, mkexpr(ones16x8),
777 unop( Iop_64HIto32, mkexpr( hi64 ) ) ) ) );
780 unop( Iop_ReinterpI32asF32, unop( Iop_64to32, mkexpr( hi64 ) ) ) ) );
784 unop( Iop_64HIto32, mkexpr( lo64 ) ) ) ) );
787 unop( Iop_ReinterpI32asF32, unop( Iop_64to32, mkexpr( lo64 ) ) ) ) );
812 assign( *t3, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(hi64))) );
813 assign( *t2, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(hi64))) );
814 assign( *t1, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(lo64))) );
815 assign( *t0, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(lo64))) );
839 assign( *t3, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(hi64))) );
840 assign( *t2, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(hi64))) );
841 assign( *t1, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(lo64))) );
842 assign( *t0, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(lo64))) );
865 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
866 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
867 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
868 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
876 binop(Iop_32HLto64, mkexpr(t3), mkexpr(t2)),
877 binop(Iop_32HLto64, mkexpr(t1), mkexpr(t0))
895 binop(Iop_CmpEQ32, mkexpr(hi32),
896 binop( Iop_Sar32, mkexpr(lo32), mkU8(31))),
898 mkexpr(lo32),
901 binop(Iop_Shr32, mkexpr(hi32), mkU8(31))));
917 binop(Iop_CmpEQ32, mkexpr(hi32), mkU32(0)),
919 mkexpr(lo32),
1311 stmt( IRStmt_Put( floatGuestRegOffset( archreg ), mkexpr( high ) ) );
1312 stmt( IRStmt_Put( floatGuestRegOffset( archreg + 1 ), mkexpr( low ) ) );
1537 mkexpr(old),
1538 mkexpr(mask[i])),
1540 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
1541 mkexpr(mask[i]))));
1565 binop( Iop_And64, mkexpr( old ), mkexpr( mask[i] ) ),
1567 binop( Iop_Shr64, mkexpr( old ), mkU8( shift[i] ) ),
1568 mkexpr( mask[i] ) ) ) );
1603 mkexpr(old),
1604 mkexpr(mask[i])),
1606 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
1607 mkexpr(mask[i]))));
1617 mkexpr(old),
1618 mkexpr(mask[i])),
1620 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
1621 mkexpr(mask[i]))));
1624 assign(retval, unop(Iop_32Uto64, binop(Iop_Add32, mkexpr(nyu1), mkexpr(nyu2))));
1740 binop(Iop_And64, mkexpr(addr), mkU64(align-1)),
1751 binop(Iop_And32, mkexpr(addr), mkU32(align-1)),
1779 mkexpr(nia)
1786 mkexpr(nia)
1983 binop(Iop_OrV128, mkexpr(v0), mkexpr(v1)),
1984 binop(Iop_OrV128, mkexpr(v2), mkexpr(v3))))
1992 binop(Iop_AndV128, mkexpr(v0), mkexpr(v1)),
1993 binop(Iop_AndV128, mkexpr(v2), mkexpr(v3)))
1996 binop(Iop_Shl8, mkexpr(rOnes), mkU8(3)),
1997 binop(Iop_Shl8, mkexpr(rZeros), mkU8(1))) );
1999 putCR321( 6, binop(Iop_Shl8, mkexpr(rZeros), mkU8(1)) );
2148 unop(Iop_64HIto32, mkexpr(t64)),
2150 unop(Iop_64to32, mkexpr(t64)),
2332 unop(Iop_128HIto64, mkexpr(t128)),
2334 unop(Iop_128to64, mkexpr(t128)),
2787 return binop(Iop_And32, mkexpr(val), mkU32(mask));
2789 return mkexpr(val);
3076 mkexpr( x ), \
3083 binop( Iop_Shr32, mkexpr( src ), mkU8( 23 ) ),
3096 mkexpr( src ) ),
3101 binop( Iop_Shr64, mkexpr( src ), mkU8( 52 ) ),
3111 assign( frac_part, binop( Iop_And32, mkexpr(src), mkU32(0x007fffff)) );
3113 return mkAND1( Inf_exp, binop( Iop_CmpEQ32, mkexpr( frac_part ), mkU32( 0 ) ) );
3129 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
3130 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
3138 assign( sign_less_part, binop( Iop_And32, mkexpr( src ), mkU32( SIGN_MASK32 ) ) );
3139 return binop( Iop_CmpEQ32, mkexpr( sign_less_part ), mkU32( 0 ) );
3152 assign( sign_less_part, binop( Iop_And64, mkexpr( src ), mkU64( SIGN_MASK ) ) );
3153 hi32 = unop( Iop_64HIto32, mkexpr( sign_less_part ) );
3154 low32 = unop( Iop_64to32, mkexpr( sign_less_part ) );
3169 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
3170 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
3185 mkexpr( x ), \
3190 binop( Iop_Shr32, mkexpr( src ), mkU8( 23 ) ),
3216 binop( Iop_And32, mkexpr( tmp ),
3221 unop( Iop_1Sto32, mkexpr( is_SNAN ) ),
3223 return binop( Iop_Or32, mkexpr( mask ), mkexpr( tmp) );
3243 binop( Iop_And64, mkexpr( intermediateResult ),
3253 mkexpr( signbit_32 ),
3260 mkexpr( intermediateResult ),
3264 unop( Iop_1Uto32, mkexpr( resultantSignbit ) ),
3286 binop( Iop_And32, mkexpr( intermediateResult ),
3296 mkexpr( signbit_32 ),
3303 mkexpr( intermediateResult ),
3306 unop( Iop_1Uto32, mkexpr( resultantSignbit ) ),
3391 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3394 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3400 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3403 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3417 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3429 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3438 binop(Iop_MullS64, mkexpr(rA),
3442 binop(Iop_MullS32, mkexpr(rA),
3451 mkexpr(rA)) );
3453 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3467 mkexpr(rA), mkexpr(rB) ) );
3470 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3479 mkexpr(rA), mkexpr(rB)) );
3481 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3485 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3496 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3498 mkexpr(rB), mkexpr(old_xer_ca))) );
3500 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3501 mkexpr(old_xer_ca) );
3504 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3523 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3525 min_one, mkexpr(old_xer_ca)) ));
3527 mkexpr(rD), mkexpr(rA), min_one,
3528 mkexpr(old_xer_ca) );
3531 mkexpr(rD), mkexpr(rA), min_one );
3549 mkexpr(rA), mkexpr(old_xer_ca)) );
3551 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0),
3552 mkexpr(old_xer_ca) );
3555 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0) );
3572 IRExpr* dividend = mk64lo32Sto64( mkexpr(rA) );
3573 IRExpr* divisor = mk64lo32Sto64( mkexpr(rB) );
3578 mkexpr(rD), dividend, divisor );
3581 assign( rD, binop(Iop_DivS32, mkexpr(rA), mkexpr(rB)) );
3584 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3603 IRExpr* dividend = mk64lo32Uto64( mkexpr(rA) );
3604 IRExpr* divisor = mk64lo32Uto64( mkexpr(rB) );
3609 mkexpr(rD), dividend, divisor );
3612 assign( rD, binop(Iop_DivU32, mkexpr(rA), mkexpr(rB)) );
3615 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3633 mk64lo32Sto64( mkexpr(rA) ),
3634 mk64lo32Sto64( mkexpr(rB) )),
3639 mkexpr(rA), mkexpr(rB))) );
3655 mk64lo32Uto64( mkexpr(rA) ),
3656 mk64lo32Uto64( mkexpr(rB) ) ),
3661 mkexpr(rA), mkexpr(rB))) );
3672 IRExpr *a = unop(Iop_64to32, mkexpr(rA) );
3673 IRExpr *b = unop(Iop_64to32, mkexpr(rB) );
3677 mkexpr(rD),
3683 mkexpr(rA), mkexpr(rB))) );
3686 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3701 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA) ),
3705 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3715 mkexpr(rB), mkexpr(rA)) );
3718 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3728 mkexpr(rB), mkexpr(rA)) );
3730 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3734 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3746 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA)),
3748 mkexpr(rB), mkexpr(old_xer_ca))) );
3750 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3751 mkexpr(old_xer_ca) );
3754 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3774 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA)),
3776 min_one, mkexpr(old_xer_ca))) );
3778 mkexpr(rD), mkexpr(rA), min_one,
3779 mkexpr(old_xer_ca) );
3782 mkexpr(rD), mkexpr(rA), min_one );
3801 mkexpr(rA)), mkexpr(old_xer_ca)) );
3803 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0),
3804 mkexpr(old_xer_ca) );
3807 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0) );
3823 mkexpr(rA), mkexpr(rB))) );
3836 mkexpr(rA), mkexpr(rB))) );
3843 assign( rD, binop(Iop_Mul64, mkexpr(rA), mkexpr(rB)) );
3846 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3854 assign( rD, binop(Iop_DivS64, mkexpr(rA), mkexpr(rB)) );
3857 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3869 assign( rD, binop(Iop_DivU64, mkexpr(rA), mkexpr(rB)) );
3872 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3892 dividend = unop( Iop_64to32, mkexpr( rA ) );
3893 divisor = unop( Iop_64to32, mkexpr( rB ) );
3895 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3897 dividend = mkexpr( rA );
3898 divisor = mkexpr( rB );
3900 assign( rD, mkexpr( res) );
3905 mkexpr(res), dividend, divisor );
3927 dividend = unop( Iop_64to32, mkexpr( rA ) );
3928 divisor = unop( Iop_64to32, mkexpr( rB ) );
3930 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3932 dividend = mkexpr( rA );
3933 divisor = mkexpr( rB );
3935 assign( rD, mkexpr( res) );
3940 mkexpr(res), dividend, divisor );
3958 assign( rD, binop(Iop_DivS64E, mkexpr(rA), mkexpr(rB)) );
3960 set_XER_OV_64( PPCG_FLAG_OP_DIVDE, mkexpr( rD ),
3961 mkexpr( rA ), mkexpr( rB ) );
3970 assign( rD, binop(Iop_DivU64E, mkexpr(rA), mkexpr(rB)) );
3972 set_XER_OV_64( PPCG_FLAG_OP_DIVDEU, mkexpr( rD ),
3973 mkexpr( rA ), mkexpr( rB ) );
3988 putIReg( rD_addr, mkexpr(rD) );
3991 set_CR0( mkexpr(rD) );
4145 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
4153 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
4161 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4167 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4173 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
4179 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
4192 mkexpr(rS), mkexpr(rB)));
4198 assign(rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
4200 mkexpr(rB))));
4213 lo32 = mode64 ? unop(Iop_64to32, mkexpr(rS)) : mkexpr(rS);
4232 mkexpr(rS), mkexpr(rB))) );
4243 assign( rA, unop(Iop_8Sto64, unop(Iop_64to8, mkexpr(rS))) );
4245 assign( rA, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rS))) );
4257 unop(Iop_64to16, mkexpr(rS))) );
4260 unop(Iop_32to16, mkexpr(rS))) );
4268 mkexpr(rS), mkexpr(rB))) );
4276 mkexpr(rS), mkexpr(rB))) );
4282 assign( rA, mkexpr(rS) );
4287 mkexpr(rS), mkexpr(rB)) );
4294 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4295 unop(mkSzOp(ty, Iop_Not8), mkexpr(rB))));
4302 mkexpr(rS), mkexpr(rB)) );
4313 assign(rA, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(rS))));
4324 irx = binop(Iop_CmpNE64, mkexpr(rS), mkU64(0));
4326 unop(Iop_Clz64, mkexpr(rS)),
4337 binop( Iop_64HLtoV128, mkU64(0), mkexpr(rS) ),
4338 binop( Iop_64HLtoV128, mkU64(0), mkexpr(rB) )
4343 unop( Iop_32UtoV128, mkexpr(rS) ),
4344 unop( Iop_32UtoV128, mkexpr(rB) )
4354 assign( rA, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
4356 assign( rA, unop( Iop_64to32, unop( Iop_ReinterpF64asI64, mkexpr(frB))) );
4358 putIReg( rS_addr, mkexpr(rA));
4367 assign( frA, unop( Iop_ReinterpI64asF64, mkexpr(rB)) );
4369 assign( frA, unop( Iop_ReinterpI64asF64, unop( Iop_32Uto64, mkexpr(rB))) );
4371 putFReg( rS_addr, mkexpr(frA));
4378 putIReg( rA_addr, mkexpr(result) );
4388 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4389 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4392 putIReg( rA_addr, binop(Iop_32HLto64, mkexpr(resultHi), mkexpr(resultLo)));
4395 putIReg( rA_addr, mkexpr(result) );
4407 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4408 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4411 putIReg( rA_addr, binop(Iop_32HLto64, mkexpr(resultHi),
4412 mkexpr(resultLo)));
4415 putIReg( rA_addr, mkexpr(result) );
4430 IRExpr * rS_expr = mkexpr(rS);
4443 binop( Iop_CmpLT64U, mkexpr( idx_tmp ), mkU64( 64 ) ) );
4447 mkexpr(idx_LT64) ),
4448 unop( Iop_64to8, mkexpr( idx_tmp ) ) ) );
4455 unop( Iop_32Uto64, unop( Iop_1Uto32, mkexpr(idx_LT64 ) ) ) );
4458 mkexpr( idx_LT64_ity64 ),
4463 mkexpr( rB ),
4464 mkexpr( idx ) ) ),
4469 mkexpr( perm_bit ),
4488 putIReg( rA_addr, mkexpr(rA) );
4491 set_CR0( mkexpr(rA) );
4542 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4543 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4545 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS1))),
4546 mkexpr(iTot1)) );
4547 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4549 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS2))),
4550 mkexpr(iTot2)) );
4551 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4553 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS3))),
4554 mkexpr(iTot3)) );
4556 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4558 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))),
4559 mkexpr(iTot4)) );
4560 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4562 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS5))),
4563 mkexpr(iTot5)) );
4564 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4566 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS6))),
4567 mkexpr(iTot6)) );
4568 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)) );
4570 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS7))),
4571 mkexpr(iTot7)) );
4573 binop(Iop_And32, mkexpr(iTot8), mkU32(1))) );
4575 assign( rA, mkexpr(iTot4) );
4579 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4580 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4582 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS1))),
4583 mkexpr(iTot1)) );
4584 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4586 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS2))),
4587 mkexpr(iTot2)) );
4588 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4590 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS3))),
4591 mkexpr(iTot3)) );
4592 assign( iLo, unop(Iop_1Uto32, unop(Iop_32to1, mkexpr(iTot4) )) );
4595 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4596 assign( iTot5, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))) );
4597 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4599 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS5))),
4600 mkexpr(iTot5)) );
4601 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4603 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS6))),
4604 mkexpr(iTot6)) );
4605 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)));
4607 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS7))),
4608 mkexpr(iTot7)) );
4609 assign( iHi, binop(Iop_And32, mkU32(1), mkexpr(iTot8)) ),
4610 assign( rA, binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo)) );
4612 assign( rA, binop(Iop_Or32, mkU32(0), mkexpr(iLo)) );
4619 putIReg( rA_addr, mkexpr(rA) );
4664 r = ROTL( unop(Iop_64to32, mkexpr(rS) ), mkU8(sh_imm) );
4670 binop(Iop_And64, mkexpr(rot), mkU64(mask64)),
4676 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4698 r = ROTL( unop(Iop_64to32, mkexpr(rS) ), mkU8(sh_imm) );
4702 assign( rot, binop(Iop_Or64, mkexpr(rTmp),
4703 binop(Iop_Shl64, mkexpr(rTmp), mkU8(32))) );
4704 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4712 assign( rA, binop(Iop_Shl32, mkexpr(rS), mkU8(sh_imm)) );
4719 assign( rA, binop(Iop_Shr32, mkexpr(rS), mkU8(MaskBeg)) );
4728 ROTL(mkexpr(rS), mkU8(sh_imm)),
4746 r = ROTL( unop(Iop_64to32, mkexpr(rS)),
4747 unop(Iop_64to8, mkexpr(rB)) );
4750 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4756 ROTL(mkexpr(rS),
4757 unop(Iop_32to8, mkexpr(rB))),
4774 r = ROTL( mkexpr(rS), unop(Iop_64to8, mkexpr(rB)) );
4795 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4814 assign( rA, binop(Iop_Shr64, mkexpr(rS), mkU8(msk_imm)) );
4818 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4831 assign( rA, binop(Iop_Shl64, mkexpr(rS), mkU8(sh_imm)) );
4835 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4845 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4851 mkexpr(rA_orig))) );
4866 putIReg( rA_addr, mkexpr(rA) );
4869 set_CR0( mkexpr(rA) );
4917 val = load(Ity_I8, mkexpr(EA));
4927 val = load(Ity_I8, mkexpr(EA));
4929 putIReg( rA_addr, mkexpr(EA) );
4934 val = load(Ity_I16, mkexpr(EA));
4944 val = load(Ity_I16, mkexpr(EA));
4946 putIReg( rA_addr, mkexpr(EA) );
4951 val = load(Ity_I16, mkexpr(EA));
4961 val = load(Ity_I16, mkexpr(EA));
4963 putIReg( rA_addr, mkexpr(EA) );
4968 val = load(Ity_I32, mkexpr(EA));
4978 val = load(Ity_I32, mkexpr(EA));
4980 putIReg( rA_addr, mkexpr(EA) );
4997 val = load(Ity_I8, mkexpr(EA));
4999 putIReg( rA_addr, mkexpr(EA) );
5004 val = load(Ity_I8, mkexpr(EA));
5014 val = load(Ity_I16, mkexpr(EA));
5016 putIReg( rA_addr, mkexpr(EA) );
5021 val = load(Ity_I16, mkexpr(EA));
5031 val = load(Ity_I16, mkexpr(EA));
5033 putIReg( rA_addr, mkexpr(EA) );
5038 val = load(Ity_I16, mkexpr(EA));
5048 val = load(Ity_I32, mkexpr(EA));
5050 putIReg( rA_addr, mkexpr(EA) );
5055 val = load(Ity_I32, mkexpr(EA));
5067 putIReg( rD_addr, load(Ity_I64, mkexpr(EA)) );
5068 putIReg( rA_addr, mkexpr(EA) );
5073 putIReg( rD_addr, load(Ity_I64, mkexpr(EA)) );
5083 unop(Iop_32Sto64, load(Ity_I32, mkexpr(EA))) );
5084 putIReg( rA_addr, mkexpr(EA) );
5090 unop(Iop_32Sto64, load(Ity_I32, mkexpr(EA))) );
5105 putIReg( rD_addr, load(Ity_I64, mkexpr(EA)) );
5114 putIReg( rD_addr, load(Ity_I64, mkexpr(EA)) );
5115 putIReg( rA_addr, mkexpr(EA) );
5121 unop(Iop_32Sto64, load(Ity_I32, mkexpr(EA))) );
5141 assign(high, load(ty, mkexpr( EA ) ) );
5143 mkexpr( EA ),
5146 assign(low, load(ty, mkexpr( EA ) ) );
5148 mkexpr( EA ),
5153 mkexpr( EA ),
5156 mkexpr( EA ),
5160 putIReg( rD_addr, mkexpr( high) );
5161 putIReg( rD_addr+1, mkexpr( low) );
5212 store( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
5221 putIReg( rA_addr, mkexpr(EA) );
5222 store( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
5227 store( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
5236 putIReg( rA_addr, mkexpr(EA) );
5237 store( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
5242 store( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
5251 putIReg( rA_addr, mkexpr(EA) );
5252 store( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
5269 putIReg( rA_addr, mkexpr(EA) );
5270 store( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
5275 store( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
5284 putIReg( rA_addr, mkexpr(EA) );
5285 store( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
5290 store( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
5299 putIReg( rA_addr, mkexpr(EA) );
5300 store( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
5305 store( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
5316 putIReg( rA_addr, mkexpr(EA) );
5317 store( mkexpr(EA), mkexpr(rS) );
5322 store( mkexpr(EA), mkexpr(rS) );
5340 store( mkexpr(EA), mkexpr(rS) );
5348 putIReg( rA_addr, mkexpr(EA) );
5349 store( mkexpr(EA), mkexpr(rS) );
5379 store( mkexpr(EA_hi), mkexpr(rS) );
5380 store( mkexpr(EA_lo), getIReg( rS_addr+1 ) );
5428 irx_addr = binop(mkAdd, mkexpr(EA), mode64 ? mkU64(ea_off) : mkU32(ea_off));
5438 irx_addr = binop(mkAdd, mkexpr(EA), mode64 ? mkU64(ea_off) : mkU32(ea_off));
5463 IRExpr* e_nbytes = mkexpr(tNBytes);
5464 IRExpr* e_EA = mkexpr(EA);
5515 IRExpr* e_nbytes = mkexpr(tNBytes);
5516 IRExpr* e_EA = mkexpr(EA);
5578 load(Ity_I32, mkexpr(t_EA)) );
5581 binop(Iop_Add32, mkexpr(t_EA), mkU32(4))) );
5613 store( mkexpr(t_EA),
5615 store( binop(Iop_Add32, mkexpr(t_EA), mkU32(4)),
5672 return mkexpr(ok);
5697 assign( res, mkexpr(cr_bi) );
5702 assign( res, binop(Iop_Xor32, mkexpr(cr_bi),
5706 return mkexpr(res);
5804 binop(Iop_And32, mkexpr(cond_ok), mkexpr(ctr_ok)) );
5816 binop(Iop_CmpNE32, mkexpr(do_branch), mkU32(0)),
5851 binop(Iop_CmpEQ32, mkexpr(cond_ok), mkU32(0)),
5861 putGST( PPC_GST_CIA, mkexpr(lr_old) );
5883 binop(Iop_And32, mkexpr(cond_ok), mkexpr(ctr_ok)) );
5891 binop(Iop_CmpEQ32, mkexpr(do_branch), mkU32(0)),
5904 putGST( PPC_GST_CIA, mkexpr(lr_old) );
5966 assign( crbD, binop(Iop_And32, mkexpr(crbA), mkexpr(crbB)) );
5971 mkexpr(crbA),
5972 unop(Iop_Not32, mkexpr(crbB))) );
5977 binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB))) );
5982 binop(Iop_And32, mkexpr(crbA), mkexpr(crbB))) );
5987 binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB))) );
5991 assign( crbD, binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB)) );
5996 mkexpr(crbA),
5997 unop(Iop_Not32, mkexpr(crbB))) );
6001 assign( crbD, binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB)) );
6008 putCRbit( crbD_addr, mkexpr(crbD) );
6077 argLe = mkexpr(argL);
6078 argRe = mkexpr(argR);
6317 stmt( stmt_load(res, mkexpr(EA), NULL/*this is a load*/) );
6319 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(res), False) );
6333 stmt( stmt_load(res, mkexpr(EA), NULL/*this is a load*/) );
6335 putIReg( rD_addr, mkWidenFrom8(ty, mkexpr(res), False) );
6352 stmt( stmt_load(res, mkexpr(EA), NULL/*this is a load*/) );
6354 putIReg( rD_addr, mkWidenFrom16(ty, mkexpr(res), False) );
6378 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS)) );
6382 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
6409 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS)) );
6413 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
6443 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS)) );
6447 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
6510 stmt( stmt_load( res, mkexpr(EA), NULL/*this is a load*/) );
6512 putIReg( rD_addr, mkexpr(res) );
6536 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS)) );
6540 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
6568 mkexpr(EA), NULL/*this is a load*/) );
6570 binop(Iop_Add64, mkexpr(EA), mkU64(8) ),
6574 mkexpr(EA), NULL/*this is a load*/) );
6576 binop(Iop_Add64, mkexpr(EA), mkU64(8) ),
6581 binop( Iop_Add32, mkexpr(EA), mkU32(4) ),
6584 binop( Iop_Add32, mkexpr(EA), mkU32(12) ),
6587 putIReg( rD_addr, mkexpr(res_hi) );
6588 putIReg( rD_addr+1, mkexpr(res_lo) );
6615 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS_hi) ) );
6616 store( binop( Iop_Add64, mkexpr(EA), mkU64(8) ),
6617 mkexpr(rS_lo) );
6619 stmt( stmt_load( resSC, mkexpr(EA), mkexpr(rS_lo) ) );
6620 store( binop( Iop_Add64, mkexpr(EA), mkU64(8) ),
6621 mkexpr(rS_hi) );
6625 mkexpr(EA),
6627 mkexpr(rS_hi) ) );
6628 store( binop(Iop_Add32, mkexpr(EA), mkU32(12) ), mkexpr(rS_lo) );
6634 unop(Iop_1Uto8, mkexpr(resSC) ),
6681 assign( rS_lo32, mkNarrowTo32(ty, mkexpr(rS)) );
6682 assign( rB_lo32, mkNarrowTo32(ty, mkexpr(rB)) );
6698 mkexpr(rS_lo32),
6701 mkexpr(rB_lo32), mkU32(31)))),
6704 binop(Iop_Shl32, mkexpr(rB_lo32), mkU8(26)),
6720 mkexpr(rB_lo32)) );
6722 binop(Iop_CmpLT32U, mkU32(31), mkexpr(sh_amt)) );
6724 mkexpr(rS_lo32),
6726 IRExpr_ITE( mkexpr(outofrange),
6728 mkexpr(sh_amt)) ) );
6732 mkexpr(rA),
6733 mkWidenFrom32(ty, mkexpr(rS_lo32), True),
6734 mkWidenFrom32(ty, mkexpr(sh_amt), True ),
6749 assign( rA, binop(Iop_Sar32, mkexpr(rS_lo32),
6754 mkexpr(rA),
6755 mkWidenFrom32(ty, mkexpr(rS_lo32), /* Syned */True),
6773 mkexpr(rS_lo32),
6775 binop(Iop_And32, mkexpr(rB_lo32),
6779 binop(Iop_Shl32, mkexpr(rB_lo32),
6800 mkexpr(rS),
6802 binop(Iop_And64, mkexpr(rB), mkU64(63)))),
6805 binop(Iop_Shl64, mkexpr(rB), mkU8(57)),
6817 assign( sh_amt, binop(Iop_And64, mkU64(0x7F), mkexpr(rB)) );
6819 binop(Iop_CmpLT64U, mkU64(63), mkexpr(sh_amt)) );
6822 mkexpr(rS),
6824 IRExpr_ITE( mkexpr(outofrange),
6826 mkexpr(sh_amt)) ))
6829 mkexpr(rA), mkexpr(rS), mkexpr(sh_amt),
6842 mkexpr(rA),
6861 mkexpr(rS),
6863 binop(Iop_And64, mkexpr(rB), mkU64(63)))),
6866 binop(Iop_Shl64, mkexpr(rB), mkU8(57)),
6879 putIReg( rA_addr, mkexpr(rA) );
6882 set_CR0( mkexpr(rA) );
6898 binop(Iop_Shl32, mkexpr(t), mkU8(24)),
6900 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t), mkU8(8)),
6903 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(8)),
6905 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(24)),
6917 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t), mkU8(8)),
6919 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(8)),
6951 assign( w1, unop(Iop_16Uto32, load(Ity_I16, mkexpr(EA))) );
6953 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(w2),
6959 assign( w1, load(Ity_I32, mkexpr(EA)) );
6961 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(w2),
6971 assign( w1, load( Ity_I32, mkexpr( EA ) ) );
6973 nextAddr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
6978 putIReg( rD_addr, binop( Iop_32HLto64, mkexpr( w2 ), mkexpr( w4 ) ) );
6980 putIReg( rD_addr, binop( Iop_32HLto64, mkexpr( w4 ), mkexpr( w2 ) ) );
6987 store( mkexpr(EA), unop(Iop_32to16, gen_byterev16(w1)) );
6993 store( mkexpr(EA), gen_byterev32(w1) );
7003 assign(lo, unop(Iop_64HIto32, mkexpr(rS)));
7004 assign(hi, unop(Iop_64to32, mkexpr(rS)));
7005 store( mkexpr( EA ),
7163 mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
7184 mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
7211 mkWidenFrom32(ty, unop(Iop_64HIto32, mkexpr(val)),
7216 putIReg( rD_addr, (mode64) ? mkexpr(val) :
7217 unop(Iop_64to32, mkexpr(val)) );
7253 mkNarrowTo32(ty, mkexpr(rS)),
7264 putGST( PPC_GST_XER, mkNarrowTo32(ty, mkexpr(rS)) );
7268 putGST( PPC_GST_LR, mkexpr(rS) );
7272 putGST( PPC_GST_CTR, mkexpr(rS) );
7276 putGST( PPC_GST_VRSAVE, mkNarrowTo32(ty, mkexpr(rS)) );
7280 putGST( PPC_GST_TFHAR, mkexpr(rS) );
7284 putGST( PPC_GST_TFIAR, mkexpr(rS) );
7288 putGST( PPC_GST_TEXASR, mkexpr(rS) );
7312 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
7334 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
7359 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( rA ), mkU64( 0 ) ) );
7364 mkexpr( rA ) ),
7388 unop( Iop_32Sto64, mkexpr( rA ) ),
7412 binop( Iop_32HLto64, mkU32( 0 ), mkexpr ( rA ) ),
7524 mkexpr(EA),
7528 irx_addr = binop( Iop_Add64, mkexpr(addr), mkU64(i*8) );
7534 mkexpr(EA),
7538 irx_addr = binop( Iop_Add32, mkexpr(addr), mkU32(i*4) );
7556 mkexpr(EA),
7558 putGST( PPC_GST_CMSTART, mkexpr(addr) );
7602 mkexpr(rm_PPC32),
7604 binop(Iop_Shl32, mkexpr(rm_PPC32), mkU8(1)),
7630 mkexpr( rm_PPC32 ),
7632 binop( Iop_Shl32, mkexpr( rm_PPC32 ), mkU8( 1 ) ),
7681 mkexpr( frac_mask ) ),
7693 mkexpr( exp_zero ),
7694 mkexpr( frac_not_zero ) ) );
7759 unop(Iop_F32toF64, load(Ity_F32, mkexpr(EA))) );
7768 unop(Iop_F32toF64, load(Ity_F32, mkexpr(EA))) );
7769 putIReg( rA_addr, mkexpr(EA) );
7775 putFReg( frD_addr, load(Ity_F64, mkexpr(EA)) );
7783 putFReg( frD_addr, load(Ity_F64, mkexpr(EA)) );
7784 putIReg( rA_addr, mkexpr(EA) );
7798 load(Ity_F32, mkexpr(EA))) );
7807 unop(Iop_F32toF64, load(Ity_F32, mkexpr(EA))) );
7808 putIReg( rA_addr, mkexpr(EA) );
7814 putFReg( frD_addr, load(Ity_F64, mkexpr(EA)) );
7822 putFReg( frD_addr, load(Ity_F64, mkexpr(EA)) );
7823 putIReg( rA_addr, mkexpr(EA) );
7829 assign( iLo, load(Ity_I32, mkexpr(EA)) );
7832 binop(Iop_Shr32, mkexpr(iLo), mkU8(31))) );
7834 binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo))) );
7842 assign( iLo, load(Ity_I32, mkexpr(EA)) );
7843 assign( dw, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( iLo ) ) );
7844 putFReg( frD_addr, unop( Iop_ReinterpI64asF64, mkexpr( dw ) ) );
7901 store( mkexpr(EA), unop(Iop_TruncF64asF32, mkexpr(frS)) );
7910 store( mkexpr(EA), unop(Iop_TruncF64asF32, mkexpr(frS)) );
7911 putIReg( rA_addr, mkexpr(EA) );
7917 store( mkexpr(EA), mkexpr(frS) );
7925 store( mkexpr(EA), mkexpr(frS) );
7926 putIReg( rA_addr, mkexpr(EA) );
7939 store( mkexpr(EA),
7940 unop(Iop_TruncF64asF32, mkexpr(frS)) );
7949 store( mkexpr(EA), unop(Iop_TruncF64asF32, mkexpr(frS)) );
7950 putIReg( rA_addr, mkexpr(EA) );
7956 store( mkexpr(EA), mkexpr(frS) );
7964 store( mkexpr(EA), mkexpr(frS) );
7965 putIReg( rA_addr, mkexpr(EA) );
7972 store( mkexpr(EA),
7973 unop(Iop_64to32, unop(Iop_ReinterpF64asI64, mkexpr(frS))) );
8035 rm, mkexpr(frA), mkexpr(frB) ));
8044 rm, mkexpr(frA), mkexpr(frB) ));
8053 rm, mkexpr(frA), mkexpr(frB) ));
8064 assign( frD, binop( Iop_SqrtF64, rm, mkexpr(frB) ));
8077 ieee_one, mkexpr(frB) ));
8087 rm, mkexpr(frA), mkexpr(frC) ));
8097 assign( frD, unop(Iop_RSqrtEst5GoodF64, mkexpr(frB)) );
8113 assign( frD, triop(Iop_DivF64, rm, mkexpr(frA), mkexpr(frB)) );
8121 assign( frD, triop(Iop_SubF64, rm, mkexpr(frA), mkexpr(frB)) );
8129 assign( frD, triop(Iop_AddF64, rm, mkexpr(frA), mkexpr(frB)) );
8138 assign( frD, binop(Iop_SqrtF64, rm, mkexpr(frB)) );
8151 assign( cc, binop(Iop_CmpF64, mkexpr(frA),
8153 assign( cc_b0, binop(Iop_And32, mkexpr(cc), mkU32(1)) );
8159 binop(Iop_CmpEQ32, mkexpr(cc_b0), mkU32(0)),
8160 mkexpr(frC),
8161 mkexpr(frB) ));
8180 ieee_one, mkexpr(frB) ));
8189 assign( frD, triop(Iop_MulF64, rm, mkexpr(frA), mkexpr(frC)) );
8198 assign( frD, unop(Iop_RSqrtEst5GoodF64, mkexpr(frB)) );
8212 putFReg( frD_addr, mkexpr(frD) );
8268 rm = mkexpr(rmt);
8289 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
8296 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
8306 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
8311 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
8314 assign( nan_mask, Check_NaN( mkexpr( tmp ),
8316 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
8317 mkexpr( nan_mask ) ) );
8318 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
8333 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
8340 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
8350 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
8355 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
8358 assign( nan_mask, Check_NaN( mkexpr( tmp ),
8360 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
8361 mkexpr( nan_mask ) ) );
8362 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
8376 putFReg( frD_addr, mkexpr(frD) );
8418 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
8431 eb_LTE = binop( Iop_CmpLE32S, mkexpr( e_b ), mkU32( test_value ) );
8435 sp ? mkexpr( frB_Int ) : unop( Iop_64HIto32, mkexpr( frB_Int ) ),
8455 assign( frac_part, binop( Iop_And32, mkexpr(frB_Int), mkU32(0x007fffff)) );
8457 = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ), mkU32( 0 ) ),
8458 binop( Iop_CmpNE32, mkexpr( frac_part ), mkU32( 0 ) ) );
8464 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
8465 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
8469 = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ), mkU32( 0 ) ),
8475 fe_flag = mkOR1( mkexpr( frbZero_tmp ),
8477 mkOR1( mkexpr( frbInf_tmp ),
8482 fg_flag = mkOR1( mkexpr( frbZero_tmp ),
8483 mkOR1( mkexpr( frbInf_tmp ), frbDenorm ) );
8544 assign(e_a, binop( Iop_Sub32, mkexpr(frA_exp_shR), mkU32( bias ) ));
8545 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
8584 eb_LTE = binop(Iop_CmpLE32S, mkexpr(e_b), mkU32(test_value));
8593 eb_GTE = binop(Iop_CmpLT32S, mkU32(test_value), mkexpr(e_b));
8600 ea_eb_GTE = mkAND1( mkexpr( fraNotZero_tmp ),
8602 binop( Iop_Sub32, mkexpr( e_a ),
8603 mkexpr( e_b ) ) ) );
8611 ea_eb_LTE = mkAND1( mkexpr( fraNotZero_tmp ),
8614 mkexpr( e_a ),
8615 mkexpr( e_b ) ),
8625 ea_LTE = mkAND1( mkexpr( fraNotZero_tmp ), binop( Iop_CmpLE32S,
8626 mkexpr( e_a ),
8656 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
8657 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
8661 frbDenorm = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ),
8671 mkexpr( fraInf_tmp ),
8673 mkexpr( frbZero_tmp ),
8677 mkexpr( frbInf_tmp ),
8686 fg_flag = mkOR1( mkexpr( fraInf_tmp ), mkOR1( mkexpr( frbZero_tmp ),
8687 mkOR1( mkexpr( frbInf_tmp ),
8708 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
8709 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) );
8762 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
8763 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) ) );
8764 putGST_field( PPC_GST_CR, mkexpr(flags), crfD );
8804 assign( ccIR, binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)) );
8831 binop(Iop_Shr32, mkexpr(ccIR), mkU8(5))
8839 mkexpr(ccIR),
8840 binop(Iop_Shr32, mkexpr(ccIR), mkU8(6))
8849 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), crfD );
8852 putGST_field( PPC_GST_FPSCR, mkexpr(ccPPC32), 4 );
8918 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8920 mkexpr( r_tmp64 ) ) ) );
8925 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8926 assign( frD, unop( Iop_F32toF64, binop( Iop_I64UtoF32, rm, mkexpr( r_tmp64 ) ) ) );
8935 assign( frD, binop( Iop_RoundF64toF32, rm, mkexpr(frB) ));
8941 binop(Iop_F64toI32S, rm, mkexpr(frB)) );
8943 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8951 binop(Iop_F64toI32S, mkU32(Irrm_ZERO), mkexpr(frB) ));
8953 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8964 mkexpr( frB ) ) );
8966 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8975 binop(Iop_F64toI64S, rm, mkexpr(frB)) );
8976 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8984 binop(Iop_F64toI64S, mkU32(Irrm_ZERO), mkexpr(frB)) );
8985 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8995 binop(Iop_F64toI64U, opc2 == 0x3AE ? rm : mkU32(Irrm_ZERO), mkexpr(frB)) );
8996 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
9003 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
9005 binop(Iop_I64StoF64, rm, mkexpr(r_tmp64)) );
9010 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
9011 assign( frD, binop( Iop_I64UtoF64, rm, mkexpr( r_tmp64 ) ) );
9019 binop(Iop_F64toI64S, mkU32(Irrm_NEAREST), mkexpr(frB)) );
9024 binop(Iop_F64toI64S, mkU32(Irrm_ZERO), mkexpr(frB)) );
9029 binop(Iop_F64toI64S, mkU32(Irrm_PosINF), mkexpr(frB)) );
9034 binop(Iop_F64toI64S, mkU32(Irrm_NegINF), mkexpr(frB)) );
9048 unop(Iop_AbsF64, mkexpr(frB)))),
9050 mkexpr(frB),
9056 mkexpr(frB))),
9062 mkexpr(r_tmp64)) )),
9063 binop(Iop_I64StoF64, mkU32(0), mkexpr(r_tmp64) )
9073 putFReg( frD_addr, mkexpr(frD) );
9151 assign( EA_lo, binop(Iop_Add64, mkexpr(EA_hi), mkU64(8)) );
9153 assign( EA_lo, binop(Iop_Add32, mkexpr(EA_hi), mkU32(8)) );
9159 putFReg( frT_hi_addr, load(Ity_F64, mkexpr(EA_hi)) );
9160 putFReg( frT_lo_addr, load(Ity_F64, mkexpr(EA_lo)) );
9162 store( mkexpr(EA_hi), mkexpr(frT_hi) );
9163 store( mkexpr(EA_lo), mkexpr(frT_lo) );
9196 mkexpr(frA) ) ),
9199 mkexpr(frB) ) ) ) ) );
9209 mkexpr(frA) ) ),
9212 mkexpr(frB) ) ) ) ) );
9220 putFReg( frD_addr, mkexpr(frD) );
9264 mkexpr(frA))),
9267 assign( itmpB, unop(Iop_ReinterpF64asI64, mkexpr(frB)) );
9273 mkexpr(itmpB)), /* frB's high 32 bits */
9275 mkexpr(signA)) );
9280 mkexpr(hiD),
9282 mkexpr(itmpB)))) ); /* frB's low 32 bits */
9287 assign( frD, unop( Iop_NegF64, mkexpr(frB) ));
9292 assign( frD, mkexpr(frB) );
9297 assign( frD, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr(frB) )));
9302 assign( frD, unop( Iop_AbsF64, mkexpr(frB) ));
9310 putFReg( frD_addr, mkexpr(frD) );
9374 putGST_field( PPC_GST_CR, mkexpr(tmp), crfD );
9488 assign( rB_64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
9489 putGST_masked( PPC_GST_FPSCR, mkexpr( rB_64 ), mask );
9532 #define NOT(x) unop( Iop_1Uto32, unop( Iop_Not1, unop( Iop_32to1, mkexpr( x ) ) ) )
9590 mkexpr( lmexp_00_mask ),
9593 mkexpr( lmexp_01_mask ),
9595 binop( Iop_And32, mkexpr( lmexp_10_mask ), mkU32( 28 ) ) ) );
9600 mkexpr( lmexp_00_mask ),
9603 mkexpr( lmexp_01_mask ),
9605 binop( Iop_And32, mkexpr( lmexp_10_mask ), mkU32( 29 ) ) ) );
9611 mkexpr( lmd_07_mask ),
9612 mkexpr( lmd_07_val ) ),
9614 mkexpr( lmd_8_mask ),
9615 mkexpr( lmd_8_val ) ) ),
9616 binop( Iop_And32, mkexpr( lmd_9_mask ), mkexpr( lmd_9_val ) ) );
9685 OR( OR3 ( AND( mkexpr( lmd_07_mask ), mkexpr( lmd_07_val ) ),
9686 AND( mkexpr( lmd_8_00_mask ), mkexpr( lmd_8_val ) ),
9687 AND( mkexpr( lmd_8_01_mask ), mkexpr( lmd_8_val ) )),
9688 OR4( AND( mkexpr( lmd_8_10_mask ), mkexpr( lmd_8_val ) ),
9689 AND( mkexpr( lmd_9_00_mask ), mkexpr( lmd_9_val ) ),
9690 AND( mkexpr( lmd_9_01_mask ), mkexpr( lmd_9_val ) ),
9691 AND( mkexpr( lmd_9_10_mask ), mkexpr( lmd_9_val ) )
9836 return unop( Iop_Not32, mkexpr( valid ) );
9916 assign( tmplow60, unop( Iop_DPBtoBCD, mkexpr( low_50 ) ) );
9917 assign( *low_60_u, unop( Iop_64HIto32, mkexpr( tmplow60 ) ) );
9918 assign( *low_60_l, unop( Iop_64to32, mkexpr( tmplow60 ) ) );
9945 assign( tmpmid60, unop( Iop_DPBtoBCD, mkexpr( mid_50 ) ) );
9946 assign( *mid_60_u, unop( Iop_64HIto32, mkexpr( tmpmid60 ) ) );
9947 assign( *mid_60_l, unop( Iop_64to32, mkexpr( tmpmid60 ) ) );
9962 assign( tmptop12, unop( Iop_DPBtoBCD, mkexpr( top_10 ) ) );
9963 assign( top_12_u, unop( Iop_64HIto32, mkexpr( tmptop12 ) ) );
9964 assign( *top_12_l, unop( Iop_64to32, mkexpr( tmptop12 ) ) );
9985 mkexpr( cnt[i-1] ),
9995 mkexpr( flag[i - 1] ),
10008 mkexpr( flag[i - 1] ) ) );
10026 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
10029 mkexpr( num_lmd ),
10030 mkexpr( lmd_flag ),
10036 mkexpr( num_upper ),
10037 mkexpr( upper_flag ),
10042 return mkexpr( num_low );
10066 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
10069 mkexpr( num_lmd ),
10070 mkexpr( lmd_flag ),
10076 mkexpr( num_top ),
10077 mkexpr( top_flag ),
10085 mkexpr( num_mid_u ),
10086 mkexpr( mid_u_flag ),
10092 mkexpr( num_mid_l ),
10093 mkexpr( mid_l_flag ),
10101 mkexpr( num_low_u ),
10102 mkexpr( low_u_flag ),
10107 return mkexpr( num_low_l );
10124 mkexpr( gfield0to5 ),
10128 mkexpr( gfield0to5 ),
10175 assign( frS, triop( Iop_AddD64, round, mkexpr( frA ), mkexpr( frB ) ) );
10180 assign( frS, triop( Iop_SubD64, round, mkexpr( frA ), mkexpr( frB ) ) );
10185 assign( frS, triop( Iop_MulD64, round, mkexpr( frA ), mkexpr( frB ) ) );
10190 assign( frS, triop( Iop_DivD64, round, mkexpr( frA ), mkexpr( frB ) ) );
10194 putDReg( frS_addr, mkexpr( frS ) );
10233 assign( frS, triop( Iop_AddD128, round, mkexpr( frA ), mkexpr( frB ) ) );
10238 assign( frS, triop( Iop_SubD128, round, mkexpr( frA ), mkexpr( frB ) ) );
10243 assign( frS, triop( Iop_MulD128, round, mkexpr( frA ), mkexpr( frB ) ) );
10248 assign( frS, triop( Iop_DivD128, round, mkexpr( frA ), mkexpr( frB ) ) );
10252 putDReg_pair( frS_addr, mkexpr( frS ) );
10280 assign( frS, binop( Iop_ShlD64, mkexpr( frA ), mkU8( shift_val ) ) );
10285 assign( frS, binop( Iop_ShrD64, mkexpr( frA ), mkU8( shift_val ) ) );
10289 putDReg( frS_addr, mkexpr( frS ) );
10317 assign( frS, binop( Iop_ShlD128, mkexpr( frA ), mkU8( shift_val ) ) );
10322 assign( frS, binop( Iop_ShrD128, mkexpr( frA ), mkU8( shift_val ) ) );
10326 putDReg_pair( frS_addr, mkexpr( frS ) );
10355 assign( frS, unop( Iop_D32toD64, mkexpr( frB ) ) );
10356 putDReg( frS_addr, mkexpr( frS ) );
10364 assign( frS, binop( Iop_D64toD32, round, mkexpr( frB ) ) );
10365 putDReg32( frS_addr, mkexpr( frS ) );
10376 assign( tmp, binop( Iop_D64toI64S, round, mkexpr( frB ) ) );
10377 assign( frS, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10378 putDReg( frS_addr, mkexpr( frS ) );
10389 unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) ) );
10390 putDReg( frS_addr, mkexpr( frS ) );
10420 assign( frS128, unop( Iop_D64toD128, mkexpr( frB64 ) ) );
10421 putDReg_pair( frS_addr, mkexpr( frS128 ) );
10430 assign( tmp, binop( Iop_D128toI64S, round, mkexpr( frB128 ) ) );
10431 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10432 putDReg( frS_addr, mkexpr( frS64 ) );
10439 assign( frS64, binop( Iop_D128toD64, round, mkexpr( frB128 ) ) );
10440 putDReg( frS_addr, mkexpr( frS64 ) );
10453 mkexpr( frB64 ) ) ) );
10454 putDReg_pair( frS_addr, mkexpr( frS128 ) );
10496 mkexpr( frB ) ) );
10497 putDReg( frS_addr, mkexpr( frS ) );
10537 mkexpr( frB ) ) );
10538 putDReg_pair( frS_addr, mkexpr( frS ) );
10597 assign( frA, binop( Iop_InsertExpD64, mkexpr( TE_I64 ),
10602 mkexpr( frA ),
10603 mkexpr( frB ) ) );
10612 mkexpr( frA ),
10613 mkexpr( frB ) ) );
10626 mkexpr( frA ) ) ) ) );
10629 mkexpr( tmp ),
10630 mkexpr( frB ) ) );
10637 putDReg( frS_addr, mkexpr( frS ) );
10693 binop( Iop_InsertExpD128, mkexpr( TE_I64 ),
10698 mkexpr( frA ),
10699 mkexpr( frB ) ) );
10707 mkexpr( frA ),
10708 mkexpr( frB ) ) );
10721 mkexpr( frA ) ) ) ) ) );
10724 mkexpr( tmp ),
10725 mkexpr( frB ) ) );
10732 putDReg_pair( frS_addr, mkexpr( frS ) );
10762 assign( tmp, unop( Iop_ExtractExpD64, mkexpr( frB ) ) );
10763 assign( frS, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10770 mkexpr( frA ) ),
10771 mkexpr( frB ) ) );
10778 putDReg( frS_addr, mkexpr( frS ) );
10812 assign( tmp, unop( Iop_ExtractExpD128, mkexpr( frB ) ) );
10813 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10814 putDReg( frS_addr, mkexpr( frS64 ) );
10821 unop( Iop_ReinterpD64asI64, mkexpr( frA ) ),
10822 mkexpr( frB ) ) );
10823 putDReg_pair( frS_addr, mkexpr( frS ) );
10863 assign( ccIR, binop( Iop_CmpD64, mkexpr( frA ), mkexpr( frB ) ) );
10872 assign( ccIR, binop( Iop_CmpD128, mkexpr( frA ), mkexpr( frB ) ) );
10897 mkexpr( ccIR ),
10902 mkexpr( ccIR ),
10904 mkexpr( ccIR ),
10908 putGST_field( PPC_GST_CR, mkexpr( ccPPC32 ), crfD );
10952 mkexpr( frA ) ) ) );
10955 mkexpr( frB ) ) ) );
10962 assign( frA, unop( Iop_D128HItoD64, mkexpr( frA128 ) ) );
10963 assign( frB, unop( Iop_D128HItoD64, mkexpr( frB128 ) ) );
10967 mkexpr( frA128 ) ) ) );
10970 mkexpr( frB128 ) ) ) );
10979 mkexpr( gfield_mask ),
10982 mkexpr(frA) ) ) ) );
10985 mkexpr( gfield_mask ),
10988 mkexpr(frB) ) ) ) );
10994 mkexpr( gfield_A ),
10998 mkexpr( gfield_A ),
11004 mkexpr( gfield_B ),
11008 mkexpr( gfield_B ),
11016 mkexpr( gfield_A ),
11022 mkexpr( gfield_B ),
11029 mkexpr( A_NaN_true ),
11030 mkexpr( B_NaN_true ) ),
11032 mkexpr( A_inf_true ),
11033 mkexpr( B_inf_true ) ) ) ) );
11044 mkexpr( exponent_A ),
11045 mkexpr( exponent_B ) ) ),
11048 mkexpr( A_inf_true ),
11049 mkexpr( B_inf_true ) ),
11051 mkexpr( A_NaN_true ),
11052 mkexpr( B_NaN_true ) ) ) ) );
11055 mkexpr( finite_number ),
11059 mkexpr( exponent_A ),
11060 mkexpr( exponent_B ) ) ),
11064 mkexpr( finite_number ),
11068 mkexpr( exponent_B ),
11069 mkexpr( exponent_A ) ) ),
11074 mkexpr( A_equals_B ),
11079 unop( Iop_Not32, mkexpr( A_equals_B ) ),
11084 mkexpr ( A_inf_true ),
11085 mkexpr ( B_inf_true ) ),
11087 mkexpr ( A_NaN_true ),
11088 mkexpr ( B_NaN_true ) ) )
11094 mkexpr( cc0 ),
11096 mkexpr( cc1 ),
11098 mkexpr( cc2 ),
11099 mkexpr( cc3 ) ) ) ),
11168 assign( frAI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frA ) ) );
11173 mkexpr( frA ) ),
11188 mkexpr( frA ) ) ) );
11195 mkexpr( exp_min_normal ),
11196 mkexpr( significand64 ) ) );
11200 mkexpr( abs_frA ),
11201 mkexpr( min_subnormalD64 ) ) );
11206 mkexpr( abs_frA ),
11238 mkexpr( exp_min_normal ),
11239 mkexpr( significand128 ) ) );
11247 mkexpr( frA ) ),
11250 mkexpr( min_subnormalD128 ) ) );
11254 mkexpr( abs_frA ),
11272 mkexpr( gfield_mask ),
11274 mkexpr(frAI64_hi) ) ) );
11291 mkexpr( gfield ) ),
11299 mkexpr( gfield ) ),
11308 mkexpr( gfield ) ),
11311 mkexpr( SNaN_true ) ) ) );
11317 mkexpr( ccIR_zero ),
11321 mkexpr( infinity_true ),
11323 mkexpr( QNaN_true ),
11324 mkexpr( SNaN_true ) ) ) ) ) );
11334 mkexpr( ccIR_subnormal ),
11338 mkexpr( ccIR_subnormal ),
11343 mkexpr( infinity_true ),
11344 mkexpr( zero_true) ),
11346 mkexpr( QNaN_true ),
11347 mkexpr( SNaN_true ) ) ) ) ) );
11354 mkexpr( infinity_true ),
11355 mkexpr( zero_true ) ),
11357 mkexpr( subnormal_true ),
11359 mkexpr( QNaN_true ),
11360 mkexpr( SNaN_true ) ) ) ) ) );
11376 mkexpr( zero_true ),
11380 mkexpr( subnormal_true ),
11385 mkexpr( normal_true ),
11390 mkexpr( infinity_true),
11395 mkexpr( QNaN_true ),
11398 assign( dcm5, binop( Iop_And32, mkexpr( SNaN_true), mkU32( 1 ) ) );
11405 mkexpr( exponent ),
11409 mkexpr( exponent ),
11414 mkexpr( gfield ), mkU8( 31 - 5 ) ) );
11418 mkexpr( lmd ),
11435 mkexpr( extreme_true ) ),
11436 mkexpr( zero_true ) ),
11443 mkexpr( extreme_true ),
11444 mkexpr( zero_true ) ),
11452 mkexpr( extreme_true ),
11453 mkexpr( normal_true ) ),
11454 mkexpr( subnormal_true ) ),
11463 mkexpr( extreme_true ) ),
11464 mkexpr( normal_true ) ),
11467 mkexpr( lmd ),
11477 mkexpr( extreme_true ) ),
11478 mkexpr( normal_true ) ),
11481 mkexpr( lmd ),
11488 mkexpr( SNaN_true),
11490 mkexpr( QNaN_true),
11491 mkexpr( infinity_true) ) ),
11498 mkexpr( dcm0 ),
11500 mkexpr( dcm1 ),
11502 mkexpr( dcm2 ),
11504 mkexpr( dcm3 ),
11506 mkexpr( dcm4 ),
11507 mkexpr( dcm5 ) ) ) ) ) ) );
11514 unop( Iop_64HIto32, mkexpr( frAI64_hi ) ),
11533 mkexpr( sign ),
11540 mkexpr( DCM_calc ) ),
11544 putGST_field( PPC_GST_CR, mkexpr( field ), crfD );
11566 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
11572 assign( bcd64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
11573 assign( bcd_u, unop( Iop_64HIto32, mkexpr( bcd64 ) ) );
11574 assign( bcd_l, unop( Iop_64to32, mkexpr( bcd64 ) ) );
11580 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11586 binop( Iop_Shl32, mkexpr( lmd ), mkU8( 28 ) ),
11587 mkexpr( bcd_u ) ),
11588 mkexpr( bcd_l ) ) );
11603 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11615 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11619 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
11632 mkexpr( bcd_l ),
11635 mkexpr( bcd_u ),
11638 mkexpr( sign ),
11640 mkexpr( bcd_l ),
11644 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result ) ) );
11661 assign( dbcd64, unop( Iop_BCDtoDPB, mkexpr(frBI64 ) ) );
11662 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( dbcd64 ) ) );
11663 assign( dbcd_l, unop( Iop_64to32, mkexpr( dbcd64 ) ) );
11668 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11673 bcd_digit_inval( unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11674 unop( Iop_64to32, mkexpr( frBI64 ) ) ) );
11675 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11683 mkexpr( dbcd_u ),
11684 mkexpr( dbcd_l ) ) ) ) ) );
11688 unop( Iop_64HIto32, mkexpr( without_lmd ) ),
11694 Gfield_encoding( mkexpr( left_exp ), mkexpr( lmd ) ),
11702 mkexpr( without_lmd ) ),
11704 mkexpr( g0_4 ) ),
11705 unop( Iop_64to32, mkexpr( without_lmd ) ) ) );
11721 mkexpr( frBI64 ) ),
11726 mkexpr( frBI64 ) ),
11730 mkexpr( frBI64 ) ),
11733 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( tmp ) ) );
11734 assign( dbcd_l, unop( Iop_64to32, mkexpr( tmp ) ) );
11739 unop( Iop_64to32, mkexpr( frBI64 ) ),
11742 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
11743 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
11745 Generate_sign_bit( mkexpr( pos_sign_mask ),
11746 mkexpr( neg_sign_mask ) ) );
11754 mkexpr( frBI64 ) ),
11757 mkexpr( frBI64 ) ),
11759 mkexpr( pos_sign_mask ),
11760 mkexpr( neg_sign_mask ) ) );
11762 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11772 mkexpr( dbcd_u ),
11773 mkexpr( sign_bit ) ),
11774 mkexpr( dbcd_l ) ) ) ) ) );
11785 mkexpr( valid_mask ),
11787 mkexpr( tmp64 ) ) ),
11790 mkexpr( invalid_mask ) ) ),
11793 mkexpr( valid_mask ),
11794 unop( Iop_64to32, mkexpr( tmp64 ) ) ),
11797 mkexpr( invalid_mask ) ) ) ) ) );
11798 putDReg( frT_addr, mkexpr( resultD64 ) );
11826 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
11827 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
11843 Generate_132_bit_bcd_string( mkexpr( frBI64_hi ),
11844 mkexpr( frBI64_lo ),
11857 mkexpr( top_12_l ),
11860 mkexpr( mid_60_u ),
11864 mkexpr( mid_60_u ),
11867 mkexpr( mid_60_l ),
11874 mkexpr( mid_60_l ),
11876 mkexpr( low_60_u ) ),
11877 mkexpr( low_60_l ) ) );
11891 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11904 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11908 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
11918 mkexpr( top_12_l ),
11920 mkexpr( mid_60_u ) ),
11921 mkexpr( mid_60_l ) ) );
11927 mkexpr( low_60_u ),
11930 mkexpr( low_60_l ),
11934 mkexpr( low_60_l ),
11936 mkexpr( sign ) ) ) );
11939 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result_hi ) ) );
11941 unop( Iop_ReinterpI64asD64, mkexpr( result_lo ) ) );
11978 mkexpr( frBI64_hi ) ),
11986 mkexpr( frBI64_hi ) ),
11990 mkexpr( frBI64_hi ) ),
11995 mkexpr( frBI64_hi ) ),
11999 mkexpr( frBI64_lo ) ),
12003 assign( bcd_low_60, mkexpr( frBI64_lo ) );
12005 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr( bcd_top_8 ) ) );
12006 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
12008 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr( bcd_mid_60 ) ) );
12009 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
12010 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
12012 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
12013 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
12014 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
12026 mkexpr( bcd_top_8 ) ) ),
12029 mkexpr( bcd_mid_60 ) ),
12031 mkexpr( bcd_mid_60 ) ) ),
12033 mkexpr( bcd_low_60 ) ),
12035 mkexpr( bcd_low_60 ) )
12047 unop( Iop_64to32, mkexpr( frBI64_lo ) ),
12049 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
12050 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
12052 Generate_sign_bit( mkexpr( pos_sign_mask ),
12053 mkexpr( neg_sign_mask ) ) );
12060 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
12064 assign( bcd_mid_60, mkexpr( frBI64_hi ) );
12071 mkexpr( frBI64_lo ) ),
12076 mkexpr( frBI64_lo ) ),
12080 mkexpr( frBI64_lo ) ),
12082 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr(bcd_top_8 ) ) );
12083 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
12085 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr(bcd_mid_60 ) ) );
12086 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
12087 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
12089 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
12090 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
12091 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
12104 bcd_digit_inval( mkexpr( zero ),
12106 mkexpr( bcd_top_8 ) ) ),
12109 mkexpr( bcd_mid_60 ) ),
12111 mkexpr( bcd_mid_60 ) ) ),
12113 mkexpr( frBI64_lo ) ),
12116 mkexpr( frBI64_lo ) ),
12119 Generate_inv_mask( mkexpr( inval_bcd_digit_mask ),
12120 mkexpr( pos_sign_mask ),
12121 mkexpr( neg_sign_mask ) ) );
12125 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
12135 mkexpr( sign_bit ),
12136 mkexpr( dbcd_top_l ) ),
12139 mkexpr( dbcd_mid_u ),
12142 mkexpr( dbcd_mid_l ),
12147 mkexpr( dbcd_low_u ),
12149 mkexpr( dbcd_mid_l ),
12151 mkexpr( dbcd_low_l ) ) ) ) );
12160 mkexpr( dfp_significand ) ) );
12164 unop( Iop_D128HItoD64, mkexpr( result128 ) ) ) );
12168 unop( Iop_D128LOtoD64, mkexpr( result128 ) ) ) );
12174 mkexpr( valid_mask ),
12175 unop( Iop_64HIto32, mkexpr( tmp_hi ) ) ),
12178 mkexpr( invalid_mask ) ) ),
12181 mkexpr( valid_mask ),
12182 unop( Iop_64to32, mkexpr( tmp_hi ) ) ),
12185 mkexpr( invalid_mask ) ) ) ) );
12191 mkexpr( valid_mask ),
12192 unop( Iop_64HIto32, mkexpr( tmp_lo ) ) ),
12195 mkexpr( invalid_mask ) ) ),
12198 mkexpr( valid_mask ),
12199 unop( Iop_64to32, mkexpr( tmp_lo ) ) ),
12202 mkexpr( invalid_mask ) ) ) ) );
12204 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result_hi ) ) );
12206 unop( Iop_ReinterpI64asD64, mkexpr( result_lo ) ) );
12245 mkexpr( frA ) ) ),
12260 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
12269 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
12272 assign( tmp64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
12273 assign( B_bcd_u, unop( Iop_64HIto32, mkexpr( tmp64 ) ) );
12274 assign( B_bcd_l, unop( Iop_64to32, mkexpr( tmp64 ) ) );
12279 Count_leading_zeros_60( mkexpr( lmd_B ),
12280 mkexpr( B_bcd_u ),
12281 mkexpr( B_bcd_l ) ) ) );
12282 assign( Unordered_true, Check_unordered( mkexpr( frBI64 ) ) );
12302 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
12303 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
12312 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
12315 Generate_132_bit_bcd_string( mkexpr( frBI64_hi ),
12316 mkexpr( frBI64_lo ),
12326 Count_leading_zeros_128( mkexpr( lmd_B ),
12327 mkexpr( B_top_12_l ),
12328 mkexpr( B_mid_60_u ),
12329 mkexpr( B_mid_60_l ),
12330 mkexpr( B_low_60_u ),
12331 mkexpr( B_low_60_l ) ) ) );
12333 assign( Unordered_true, Check_unordered( mkexpr( frBI64_hi ) ) );
12352 unop( Iop_8Uto32, mkexpr( K ) ),
12353 unop( Iop_8Uto32, mkexpr( B_sig ) ) ) ) );
12357 unop( Iop_8Uto32, mkexpr( K ) ),
12358 unop( Iop_8Uto32, mkexpr( B_sig ) ) ) ) );
12362 unop( Iop_8Uto32, mkexpr( B_sig ) ),
12363 unop( Iop_8Uto32, mkexpr( K ) ) ) ) );
12368 unop( Iop_8Uto32, mkexpr( K ) ),
12373 unop( Iop_8Uto32, mkexpr( K ) ),
12379 mkexpr( KisZero_false_mask ),
12382 mkexpr( Lt_true_mask ),
12386 mkexpr( Gt_true_mask ),
12389 mkexpr( Eq_true_mask ),
12392 mkexpr( KisZero_true_mask ),
12398 mkexpr( Unordered_true ),
12401 unop( Iop_Not32, mkexpr( Unordered_true ) ),
12402 mkexpr( field ) ) ),
12498 putGST( PPC_GST_VSCR, unop(Iop_V128to32, mkexpr(vB)) );
12600 mkexpr( xB ) ), mkU64( 0 ) ) );
12610 mkexpr( xB ) ) ),
12620 mkexpr( xB ) ),
12634 mkexpr( xB ) ) ) ),
12644 mkexpr( xB ) ) ),
12658 mkexpr( xB ) ) ) ),
12668 mkexpr( xB ) ) ),
12679 assign(hiResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB)));
12680 assign(loResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB2)));
12683 unop( Iop_32Sto64, mkexpr( hiResult_32 ) ),
12684 unop( Iop_32Sto64, mkexpr( loResult_32 ) ) ) );
12706 assign( hi64, unop(Iop_V128HIto64, mkexpr(tempResult)) );
12707 assign( lo64, unop(Iop_V128to64, mkexpr(tempResult)) );
12708 assign( res3, unop(Iop_64HIto32, mkexpr(hi64)) );
12709 assign( res2, unop(Iop_64to32, mkexpr(hi64)) );
12710 assign( res1, unop(Iop_64HIto32, mkexpr(lo64)) );
12711 assign( res0, unop(Iop_64to32, mkexpr(lo64)) );
12717 mkexpr(res3));
12722 mkexpr(res2));
12727 mkexpr(res1));
12732 mkexpr(res0));
12750 mkexpr( xB ) ) ) ),
12762 mkexpr( xB ) ) ),
12775 mkexpr( xB ) ) ),
12784 unop( Iop_ReinterpI32asF32, mkexpr( xB ) ) ) ),
12793 unop( Iop_ReinterpI32asF32, mkexpr( xB ) ) ) ),
12806 mkexpr( xB ) ) ) ),
12813 mkexpr( xB2 ) ) ) ),
12822 binop( Iop_F64toI64U, mkU32( Irrm_ZERO ), mkexpr( xB ) ),
12823 binop( Iop_F64toI64U, mkU32( Irrm_ZERO ), mkexpr( xB2 ) ) ) );
12833 mkexpr( xB ) ),
12838 mkexpr( xB2 ) ),
12848 handle_SNaN_to_QNaN_32( mkexpr( b3 ) ) ) ) ),
12852 handle_SNaN_to_QNaN_32( mkexpr( b1 ) ) ) ) ) ) );
12862 unop( Iop_ReinterpI32asF32, mkexpr( b3 ) ) ) ),
12866 unop( Iop_ReinterpI32asF32, mkexpr( b1 ) ) ) ) ) );
12876 unop( Iop_ReinterpI32asF32, mkexpr( b3 ) ) ) ),
12880 unop( Iop_ReinterpI32asF32, mkexpr( b1 ) ) ) ) ) );
12887 binop( Iop_F64toI64S, mkU32( Irrm_ZERO ), mkexpr( xB ) ),
12888 binop( Iop_F64toI64S, mkU32( Irrm_ZERO ), mkexpr( xB2 ) ) ) );
12898 mkexpr( xB ) ) ),
12902 mkexpr( xB2 ) ) ) ) );
12912 mkexpr( xB ) ) ),
12916 mkexpr( xB2 ) ) ) ) );
12931 mkexpr( xB ) ) ) ) ),
12940 mkexpr( xB2 ) ) ) ) ),
12955 mkexpr( xB ) ) ) ) ),
12964 mkexpr( xB2 ) ) ) ) ),
12974 unop( Iop_32Sto64, mkexpr( b3 ) ) ) ),
12977 unop( Iop_32Sto64, mkexpr( b1 ) ) ) ) ) );
12985 unop( Iop_32Uto64, mkexpr( b3 ) ) ) ),
12988 unop( Iop_32Uto64, mkexpr( b1 ) ) ) ) ) );
13068 triop( mOp, rm, mkexpr( frA ), mkexpr( frB ) ) ) );
13071 triop( mOp, rm, mkexpr( frA2 ), mkexpr( frB2 ) ) ) );
13073 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
13084 binop( Iop_SqrtF64, rm, mkexpr( frB ) ) ) );
13087 binop( Iop_SqrtF64, rm, mkexpr( frB2 ) ) ) );
13089 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
13152 mkexpr( frA ),
13153 mkexpr( mdp ? frT : frB ),
13154 mkexpr( mdp ? frB : frT ) ) ) );
13159 mkexpr( frA2 ),
13160 mkexpr( mdp ? frT2 : frB2 ),
13161 mkexpr( mdp ? frB2 : frT2 ) ) ) );
13164 mkexpr( negate ? getNegatedResult( hiResult )
13166 mkexpr( negate ? getNegatedResult( loResult )
13191 binop( Iop_Shl32, mkexpr(fg_flagHi), mkU8( 2 ) ) ),
13192 binop( Iop_Shl32, mkexpr(fe_flagHi), mkU8( 1 ) ) ) );
13196 binop( Iop_Shl32, mkexpr(fg_flagLo), mkU8( 2 ) ) ),
13197 binop( Iop_Shl32, mkexpr(fe_flagLo), mkU8( 1 ) ) ) );
13199 binop( Iop_Or32, mkexpr( flagsHi ), mkexpr( flagsLo ) ),
13229 binop( Iop_Shl32, mkexpr(fg_flagHi), mkU8( 2 ) ) ),
13230 binop( Iop_Shl32, mkexpr(fe_flagHi), mkU8( 1 ) ) ) );
13234 binop( Iop_Shl32, mkexpr(fg_flagLo), mkU8( 2 ) ) ),
13235 binop( Iop_Shl32, mkexpr(fe_flagLo), mkU8( 1 ) ) ) );
13237 binop( Iop_Or32, mkexpr( flagsHi ), mkexpr( flagsLo ) ),
13315 triop( Iop_DivF64r32, rm, mkexpr( a0 ), mkexpr( b0 ) ) ) ) );
13319 triop( Iop_DivF64r32, rm, mkexpr( a1 ), mkexpr( b1 ) ) ) ) );
13323 triop( Iop_DivF64r32, rm, mkexpr( a2 ), mkexpr( b2 ) ) ) ) );
13327 triop( Iop_DivF64r32, rm, mkexpr( a3 ), mkexpr( b3 ) ) ) ) );
13331 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
13332 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
13348 binop(Iop_SqrtF64, rm, mkexpr( b0 ) ) ) ) );
13352 binop(Iop_SqrtF64, rm, mkexpr( b1 ) ) ) ) );
13356 binop(Iop_SqrtF64, rm, mkexpr( b2) ) ) ) );
13360 binop(Iop_SqrtF64, rm, mkexpr( b3 ) ) ) ) );
13364 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
13365 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
13421 mkexpr( a0 ),
13422 mkexpr( msp ? t0 : b0 ),
13423 mkexpr( msp ? b0 : t0 ) ) ) ) );
13429 mkexpr( a1 ),
13430 mkexpr( msp ? t1 : b1 ),
13431 mkexpr( msp ? b1 : t1 ) ) ) ) );
13437 mkexpr( a2 ),
13438 mkexpr( msp ? t2 : b2 ),
13439 mkexpr( msp ? b2 : t2 ) ) ) ) );
13445 mkexpr( a3 ),
13446 mkexpr( msp ? t3 : b3 ),
13447 mkexpr( msp ? b3 : t3 ) ) ) ) );
13451 binop( Iop_32HLto64, mkexpr( negate ? getNegatedResult_32( res3 ) : res3 ),
13452 mkexpr( negate ? getNegatedResult_32( res2 ) : res2 ) ),
13453 binop( Iop_32HLto64, mkexpr( negate ? getNegatedResult_32( res1 ) : res1 ),
13454 mkexpr( negate ? getNegatedResult_32( res0 ) : res0 ) ) ) );
13483 binop( Iop_Shl32, mkexpr(fg_flag0), mkU8( 2 ) ) ),
13484 binop( Iop_Shl32, mkexpr(fe_flag0), mkU8( 1 ) ) ) );
13488 binop( Iop_Shl32, mkexpr(fg_flag1), mkU8( 2 ) ) ),
13489 binop( Iop_Shl32, mkexpr(fe_flag1), mkU8( 1 ) ) ) );
13493 binop( Iop_Shl32, mkexpr(fg_flag2), mkU8( 2 ) ) ),
13494 binop( Iop_Shl32, mkexpr(fe_flag2), mkU8( 1 ) ) ) );
13498 binop( Iop_Shl32, mkexpr(fg_flag3), mkU8( 2 ) ) ),
13499 binop( Iop_Shl32, mkexpr(fe_flag3), mkU8( 1 ) ) ) );
13502 mkexpr( flags0 ),
13504 mkexpr( flags1 ),
13506 mkexpr( flags2 ),
13507 mkexpr( flags3 ) ) ) ),
13538 binop( Iop_Shl32, mkexpr(fg_flag0), mkU8( 2 ) ) ),
13539 binop( Iop_Shl32, mkexpr(fe_flag0), mkU8( 1 ) ) ) );
13543 binop( Iop_Shl32, mkexpr(fg_flag1), mkU8( 2 ) ) ),
13544 binop( Iop_Shl32, mkexpr(fe_flag1), mkU8( 1 ) ) ) );
13548 binop( Iop_Shl32, mkexpr(fg_flag2), mkU8( 2 ) ) ),
13549 binop( Iop_Shl32, mkexpr(fe_flag2), mkU8( 1 ) ) ) );
13553 binop( Iop_Shl32, mkexpr(fg_flag3), mkU8( 2 ) ) ),
13554 binop( Iop_Shl32, mkexpr(fe_flag3), mkU8( 1 ) ) ) );
13557 mkexpr( flags0 ),
13559 mkexpr( flags1 ),
13561 mkexpr( flags2 ),
13562 mkexpr( flags3 ) ) ) ),
13595 putVReg( vRT_addr, unop(Iop_Clz8x16, mkexpr( vB ) ) );
13600 putVReg( vRT_addr, unop(Iop_Clz16x8, mkexpr( vB ) ) );
13605 putVReg( vRT_addr, unop(Iop_Clz32x4, mkexpr( vB ) ) );
13610 putVReg( vRT_addr, unop(Iop_Clz64x2, mkexpr( vB ) ) );
13625 breakV128to4x32(mkexpr( vB), &bits96_127, &bits64_95, &bits32_63, &bits0_31 );
13648 breakV128to4x32(mkexpr( vB), &bits96_127, &bits64_95, &bits32_63, &bits0_31 );
13672 breakV128to4x32(mkexpr( vB), &bits96_127, &bits64_95, &bits32_63, &bits0_31 );
13698 assign(bits0_63, unop( Iop_V128to64, mkexpr( vB ) ) );
13699 assign(bits64_127, unop( Iop_V128HIto64, mkexpr( vB ) ) );
13704 mkexpr( cnt_bits64_127 ),
13705 mkexpr( cnt_bits0_63 ) ) );
13716 breakV128to4x32(mkexpr( vB), &bits96_127, &bits64_95, &bits32_63, &bits0_31 );
13722 mkexpr( cnt_bits64_127 ),
13723 mkexpr( cnt_bits0_63 ) ) );
13730 putVReg( vRT_addr, unop( Iop_PwBitMtxXpose64x2, mkexpr( vB ) ) );
13781 mkexpr( ccIR ),
13786 mkexpr( ccIR ),
13788 mkexpr( ccIR ),
13815 mkAND1( mkexpr(frA_isNaN),
13818 unop( Iop_64HIto32, mkexpr( frA_I64 ) ),
13822 mkAND1( mkexpr(frB_isNaN),
13825 unop( Iop_64HIto32, mkexpr( frB_I64 ) ),
13829 mkAND1( mkexpr( frA_isNaN ), unop( Iop_Not1, mkexpr( frA_isSNaN ) ) ) );
13831 mkAND1( mkexpr( frB_isNaN ), unop( Iop_Not1, mkexpr( frB_isSNaN ) ) ) );
13850 IRExpr_ITE(mkexpr(frA_isSNaN),
13852 binop(Iop_Or64, mkexpr(frA_I64), mkU64(SNAN_MASK)),
13854 IRExpr_ITE(mkexpr(frB_isSNaN),
13856 binop(Iop_Or64, mkexpr(frB_I64), mkU64(SNAN_MASK)),
13858 IRExpr_ITE(mkexpr(frB_isQNaN),
13860 mkexpr(frA_I64),
13862 mkexpr(frB_I64))));
13872 mkexpr( src1 ) ),
13874 mkexpr( src2 ) ) ) );
13877 mkexpr( src1cmpsrc2 ),
13880 mkexpr( src1 ),
13882 mkexpr( src2 ) );
13910 mkAND1( mkexpr( frA_isZero ), mkexpr( frB_isZero ) ),
13916 mkexpr( frA_I64 ) ),
13919 mkexpr( frB_I64 ) ),
13921 IRExpr_ITE( mkexpr( anyNaN ),
13982 assign(frB, unop(Iop_ReinterpI64asF64, mkexpr(frB_I64)));
13985 mkexpr( frB ) ) );
13998 unop( Iop_AbsF64, mkexpr( frB ) ) ) ),
14000 mkexpr( frB ),
14005 mkexpr( frB_I64 ) ),
14012 mkexpr( intermediateResult ) ) ) ),
14015 mkexpr( intermediateResult ) )
14024 hi32 = unop( Iop_64HIto32, mkexpr(frB_I64) );
14031 return IRExpr_ITE( mkexpr( is_SNAN ),
14035 mkexpr( frB_I64 ) ) ),
14036 mkexpr( frD ));
14075 unop( Iop_ReinterpI64asF64, mkexpr( frB ) ) ) );
14079 unop( Iop_ReinterpI64asF64, mkexpr( frB2 ) ) ) );
14088 mkexpr( frB ) )
14089 : mkexpr( sqrtHi ) ) ),
14095 mkexpr( frB2 ) )
14096 : mkexpr( sqrtLo ) ) ) ) );
14122 assign( sqrt3, binop( Iop_SqrtF64, rm, mkexpr( b3 ) ) );
14123 assign( sqrt2, binop( Iop_SqrtF64, rm, mkexpr( b2 ) ) );
14124 assign( sqrt1, binop( Iop_SqrtF64, rm, mkexpr( b1 ) ) );
14125 assign( sqrt0, binop( Iop_SqrtF64, rm, mkexpr( b0 ) ) );
14134 resp ? mkexpr( b0 ) : mkexpr( sqrt0 ) ) ) ) );
14141 resp ? mkexpr( b1 ) : mkexpr( sqrt1 ) ) ) ) );
14148 resp ? mkexpr( b2 ) : mkexpr( sqrt2 ) ) ) ) );
14155 resp ? mkexpr( b3 ) : mkexpr( sqrt3 ) ) ) ) );
14158 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
14159 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
14188 assign( a0_I64, unop( Iop_ReinterpF64asI64, mkexpr( a0 ) ) );
14189 assign( b0_I64, unop( Iop_ReinterpF64asI64, mkexpr( b0 ) ) );
14190 assign( a1_I64, unop( Iop_ReinterpF64asI64, mkexpr( a1 ) ) );
14191 assign( b1_I64, unop( Iop_ReinterpF64asI64, mkexpr( b1 ) ) );
14192 assign( a2_I64, unop( Iop_ReinterpF64asI64, mkexpr( a2 ) ) );
14193 assign( b2_I64, unop( Iop_ReinterpF64asI64, mkexpr( b2 ) ) );
14194 assign( a3_I64, unop( Iop_ReinterpF64asI64, mkexpr( a3 ) ) );
14195 assign( b3_I64, unop( Iop_ReinterpF64asI64, mkexpr( b3 ) ) );
14218 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
14219 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
14258 mkexpr( frA ),
14261 mkexpr( frB ),
14265 mkexpr( frA2 ),
14268 mkexpr( frB2 ),
14290 unop(Iop_64to32, mkexpr( a3_I64 ) ),
14293 unop(Iop_64to32, mkexpr( b3_I64 ) ),
14298 unop(Iop_64to32, mkexpr( a2_I64 ) ),
14301 unop(Iop_64to32, mkexpr( b2_I64 ) ),
14307 unop(Iop_64to32, mkexpr( a1_I64 ) ),
14310 unop(Iop_64to32, mkexpr( b1_I64 ) ),
14315 unop(Iop_64to32, mkexpr( a0_I64 ) ),
14318 unop(Iop_64to32, mkexpr( b0_I64 ) ),
14320 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( resHi ), mkexpr( resLo ) ) );
14336 assign(abs_resultHi, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB ) ) ) );
14337 assign(abs_resultLo, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB2 ) ) ) );
14340 assign(abs_resultHi, unop( Iop_AbsF64, mkexpr( frB ) ) );
14341 assign(abs_resultLo, unop( Iop_AbsF64, mkexpr( frB2 ) ) );
14344 unop( Iop_ReinterpF64asI64, mkexpr( abs_resultHi ) ),
14345 unop( Iop_ReinterpF64asI64, mkexpr( abs_resultLo ) ) ) );
14368 mkexpr( shiftVector ) ),
14369 mkexpr( shiftVector ) ) );
14382 mkexpr( absVal_vector ),
14383 mkexpr( signBit_vector ) ) );
14385 putVSReg( XT, mkexpr( absVal_vector ) );
14399 unop( Iop_NegF64, mkexpr( frB ) ) ),
14401 unop( Iop_NegF64, mkexpr( frB2 ) ) ) ) );
14473 assign(b3_I64, unop(Iop_ReinterpF64asI64, mkexpr(b3_F64)));
14474 assign(b2_I64, unop(Iop_ReinterpF64asI64, mkexpr(b2_F64)));
14475 assign(b1_I64, unop(Iop_ReinterpF64asI64, mkexpr(b1_F64)));
14476 assign(b0_I64, unop(Iop_ReinterpF64asI64, mkexpr(b0_F64)));
14540 mkexpr( frA ),
14541 mkexpr( frB ) ) ) ),
14550 mkexpr( frA ),
14551 mkexpr( frB ) ) ) ),
14558 mkexpr( frA ),
14559 mkexpr( frB ) ) ),
14568 mkexpr( frA ),
14569 mkexpr( frB ) ) ) ),
14576 mkexpr( frA ),
14577 mkexpr( frB ) ) ),
14594 mkexpr( frA ),
14595 mkexpr( mdp ? frT : frB ),
14596 mkexpr( mdp ? frB : frT ) ) ) ),
14609 mkexpr( frA ),
14610 mkexpr( mdp ? frT : frB ),
14611 mkexpr( mdp ? frB : frT ) ) ),
14629 mkexpr( frA ),
14630 mkexpr( mdp ? frT : frB ),
14631 mkexpr( mdp ? frB : frT ) ) ) ),
14644 mkexpr( frA ),
14645 mkexpr( mdp ? frT : frB ),
14646 mkexpr( mdp ? frB : frT ) ) ),
14667 mkexpr( frA ),
14668 mkexpr( mdp ? frT : frB ),
14669 mkexpr( mdp ? frB : frT ) ) ) );
14671 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( getNegatedResult(maddResult) ),
14690 mkexpr( frA ),
14691 mkexpr( mdp ? frT : frB ),
14692 mkexpr( mdp ? frB : frT ) ) ) ) );
14695 mkexpr( getNegatedResult(maddResult) ),
14714 mkexpr( frA ),
14715 mkexpr( mdp ? frT : frB ),
14716 mkexpr( mdp ? frB : frT ) ) ) ) );
14719 mkexpr( getNegatedResult(msubResult) ),
14737 mkexpr( frA ),
14738 mkexpr( mdp ? frT : frB ),
14739 mkexpr( mdp ? frB : frT ) ) ));
14741 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( getNegatedResult(msubResult) ), mkU64( 0 ) ) );
14752 mkexpr( frA ),
14753 mkexpr( frB ) ) ) ),
14761 mkexpr( frA ),
14762 mkexpr( frB ) ) ),
14769 mkexpr( frA ),
14770 mkexpr( frB ) ) ),
14781 mkexpr( frB ) ) ) ),
14789 mkexpr( frB ) ) ),
14799 assign( frA_I64, unop( Iop_ReinterpF64asI64, mkexpr( frA ) ) );
14800 assign( frB_I64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
14820 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
14821 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) ) );
14822 putGST_field( PPC_GST_CR, mkexpr(flags), crfD );
14863 ccPPC32 = get_fp_cmp_CR_val( binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)));
14864 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), crfD );
14892 assign(frA_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vA ))));
14893 assign(frB_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vB ))));
14894 assign(frA_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vA ))));
14895 assign(frB_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vB ))));
14898 mkexpr( frA_hi ),
14899 mkexpr( frB_hi ) ) );
14901 mkexpr( frA_lo ),
14902 mkexpr( frB_lo ) ) );
14907 binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( cmp_type ) ) ) );
14910 binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( cmp_type ) ) ) );
14917 assign(hi_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 2 ) ),
14918 binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 4 ) ) ) );
14919 assign( hiResult,unop( Iop_1Sto64, mkexpr( hi_GE ) ) );
14921 assign(lo_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 2 ) ),
14922 binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 4 ) ) ) );
14923 assign( loResult, unop( Iop_1Sto64, mkexpr( lo_GE ) ) );
14929 unop( Iop_64to32, mkexpr( hiResult ) ),
14930 unop( Iop_64to32, mkexpr( loResult ) ) ) );
14932 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
14936 mkAND1( mkexpr( hiEQlo ),
14940 mkexpr( hiResult ) ) ) ) ) );
14944 mkAND1( mkexpr( hiEQlo ),
14948 mkexpr( hiResult ) ) ) ) ) );
14951 binop( Iop_Shl32, mkexpr( all_elem_false ), mkU8( 1 ) ),
14952 binop( Iop_Shl32, mkexpr( all_elem_true ), mkU8( 3 ) ) ) );
14955 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), 6 );
15013 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
15014 putVSReg( XT, mkexpr(vD) );
15016 set_AV_CR6( mkexpr(vD), True );
15027 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
15028 putVSReg( XT, mkexpr(vD) );
15030 set_AV_CR6( mkexpr(vD), True );
15041 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
15042 putVSReg( XT, mkexpr(vD) );
15044 set_AV_CR6( mkexpr(vD), True );
15091 assign( hi64, unop( Iop_V128HIto64, mkexpr(vB) ) );
15092 assign( lo64, unop( Iop_V128to64, mkexpr(vB) ) );
15094 binop( Iop_And64, mkexpr(hi64),
15096 mkexpr(lo64) ) );
15099 binop(Iop_ShlV128, mkexpr(vB),
15103 putVSReg(XT, mkexpr(absVal));
15115 mkexpr(vA)),
15119 mkexpr(vB) ),
15123 mkexpr(vecA_signed),
15124 mkexpr(vecB_unsigned) ),
15126 putVSReg(XT, mkexpr(vec_result));
15136 mkexpr(vB) ),
15139 mkexpr(BHi_signed), mkU64(0x0ULL) ) );
15151 assign( BHi_signed, unop( Iop_V128HIto64, mkexpr(vB) ) );
15152 assign( BHi_unsigned, binop( Iop_And64, mkexpr(BHi_signed),
15160 mkexpr(BHi_signed),
15169 mkexpr(BHi_negated_signbit) ),
15172 mkexpr(BHi_unsigned) ) );
15173 assign( vec_result, binop( Iop_64HLtoV128, mkexpr(BHi_negated),
15175 putVSReg( XT, mkexpr(vec_result));
15186 assign(frA, unop(Iop_V128HIto64, mkexpr( vA )));
15187 assign(frB, unop(Iop_V128HIto64, mkexpr( vB )));
15201 assign(frB_I64, unop(Iop_V128HIto64, mkexpr( vB )));
15226 unop( Iop_V128HIto64, mkexpr( vB ) ) ) );
15232 mkexpr(frB) ) );
15240 redp ? mkexpr( frB ) :
15241 mkexpr( sqrt ) ) ) ),
15258 unop( Iop_V128HIto64, mkexpr( vB ) ) ) );
15264 mkexpr(frB) ) );
15271 redp ? mkexpr( frB ) : mkexpr( sqrt ) ) ),
15283 unop( Iop_V128HIto64, mkexpr( vB ) ) ) );
15289 mkexpr( frB ) ) ),
15326 putVSReg( XT, binop( Iop_XorV128, mkexpr( vA ), mkexpr( vB ) ) );
15330 putVSReg( XT, binop( Iop_OrV128, mkexpr( vA ), mkexpr( vB ) ) );
15334 putVSReg( XT, unop( Iop_NotV128, binop( Iop_OrV128, mkexpr( vA ),
15335 mkexpr( vB ) ) ) );
15339 putVSReg( XT, binop( Iop_AndV128, mkexpr( vA ), mkexpr( vB ) ) );
15343 putVSReg( XT, binop( Iop_AndV128, mkexpr( vA ), unop( Iop_NotV128,
15344 mkexpr( vB ) ) ) );
15349 mkexpr( vA ),
15350 unop( Iop_NotV128, mkexpr( vB ) ) ) );
15355 binop( Iop_AndV128, mkexpr( vA ),
15356 mkexpr( vB ) ) ) );
15362 mkexpr( vA ), mkexpr( vB ) ) ) );
15402 exp = unop( Iop_64to32, load( Ity_I64, mkexpr( EA ) ) );
15404 exp = unop( Iop_64HIto32, load( Ity_I64, mkexpr( EA ) ) );
15417 exp = unop( Iop_64to32, load( Ity_I64, mkexpr( EA ) ) );
15419 exp = unop( Iop_64HIto32, load( Ity_I64, mkexpr( EA ) ) );
15437 load( Ity_I32, mkexpr( EA ) ) ) ) );
15446 exp = load( Ity_I64, mkexpr( EA ) );
15460 high = load( Ity_I64, mkexpr( EA ) );
15461 high_addr = binop( addOp, mkexpr( EA ), ty == Ity_I64 ? mkU64( ea_off )
15471 assign( data, load( Ity_I64, mkexpr( EA ) ) );
15472 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( data ), mkexpr( data ) ) );
15486 t0_BE = load( Ity_V128, mkexpr( EA ) );
15492 t0 = binop( Iop_Perm8x16, t0_BE, mkexpr(perm_LE) );
15494 t0 = load( Ity_V128, mkexpr( EA ) );
15541 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
15543 store( mkexpr( EA ), low32 );
15552 unop( Iop_V128HIto64, mkexpr( vS ) ) ) );
15555 mkexpr(high64) ) ) );
15556 store( mkexpr( EA ), mkexpr( val32 ) );
15563 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
15564 store( mkexpr( EA ), high64 );
15571 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
15572 low64 = unop( Iop_V128to64, mkexpr( vS ) );
15573 store( mkexpr( EA ), high64 );
15574 store( binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
15589 assign( hi64, unop( Iop_V128HIto64, mkexpr( vS ) ) );
15590 assign( lo64, unop( Iop_V128to64, mkexpr( vS ) ) );
15591 store( mkexpr( EA ), unop( Iop_64HIto32, mkexpr( hi64 ) ) );
15593 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
15595 store( irx_addr, unop( Iop_64to32, mkexpr( hi64 ) ) );
15597 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
15599 store( irx_addr, unop( Iop_64HIto32, mkexpr( lo64 ) ) );
15601 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
15603 store( irx_addr, unop( Iop_64to32, mkexpr( lo64 ) ) );
15645 assign( hi, binop(Iop_ShlV128, mkexpr(vA), mkU8(SHW*32)) );
15646 assign( lo, binop(Iop_ShrV128, mkexpr(vB), mkU8(128-SHW*32)) );
15647 assign ( result, binop(Iop_OrV128, mkexpr(hi), mkexpr(lo)) );
15649 assign ( result, mkexpr(vA) );
15651 putVSReg( XT, mkexpr(result) );
15661 assign( hi, unop(Iop_V128to64, mkexpr(vA)) );
15663 assign( hi, unop(Iop_V128HIto64, mkexpr(vA)) );
15666 assign( lo, unop(Iop_V128to64, mkexpr(vB)) );
15668 assign( lo, unop(Iop_V128HIto64, mkexpr(vB)) );
15670 assign( vT, binop(Iop_64HLtoV128, mkexpr(hi), mkexpr(lo)) );
15673 putVSReg( XT, mkexpr( vT ) );
15688 assign( a64, unop(word_op, mkexpr(vA)) );
15689 assign( ahi32, unop(Iop_64HIto32, mkexpr(a64)) );
15690 assign( alo32, unop(Iop_64to32, mkexpr(a64)) );
15692 assign( b64, unop(word_op, mkexpr(vB)) );
15693 assign( bhi32, unop(Iop_64HIto32, mkexpr(b64)) );
15694 assign( blo32, unop(Iop_64to32, mkexpr(b64)) );
15697 binop(Iop_32HLto64, mkexpr(ahi32), mkexpr(bhi32)),
15698 binop(Iop_32HLto64, mkexpr(alo32), mkexpr(blo32))) );
15701 putVSReg( XT, mkexpr( vT ) );
15712 binop(Iop_AndV128, mkexpr(vA), unop(Iop_NotV128, mkexpr(vC))),
15713 binop(Iop_AndV128, mkexpr(vB), mkexpr(vC))) );
15724 binop( Iop_ShrV128, mkexpr( vB ), mkU8( sh_uim ) ) ) ) );
15758 assign( EA_align16, addr_align( mkexpr(EA), 16 ) );
15768 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
15775 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
15817 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
15824 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
15866 putVReg( vD_addr, load(Ity_V128, mkexpr(EA_align16)) );
15872 putVReg( vD_addr, load(Ity_V128, mkexpr(EA_align16)) );
15878 putVReg( vD_addr, load(Ity_V128, mkexpr(EA_align16)) );
15883 putVReg( vD_addr, load(Ity_V128, mkexpr(EA_align16)) );
15888 putVReg( vD_addr, load(Ity_V128, mkexpr(EA_align16)) );
15931 mkNarrowTo32(ty, mkexpr(EA)) )) );
15933 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
15936 binop(Iop_Sub8, mkU8(15), mkexpr(eb)),
15939 store( mkexpr(EA),
15941 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx)))) );
15946 assign( addr_aligned, addr_align(mkexpr(EA), 2) );
15948 mkNarrowTo8(ty, mkexpr(addr_aligned) )) );
15950 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
15953 binop(Iop_Sub8, mkU8(14), mkexpr(eb)),
15956 store( mkexpr(addr_aligned),
15958 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx)))) );
15963 assign( addr_aligned, addr_align(mkexpr(EA), 4) );
15965 mkNarrowTo8(ty, mkexpr(addr_aligned) )) );
15967 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
15970 binop(Iop_Sub8, mkU8(12), mkexpr(eb)),
15973 store( mkexpr( addr_aligned),
15975 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx))) );
15981 store( addr_align( mkexpr(EA), 16 ), mkexpr(vS) );
15986 store( addr_align( mkexpr(EA), 16 ), mkexpr(vS) );
16038 binop(Iop_CmpGT32Ux4, mkexpr(vB),
16039 unop(Iop_NotV128, mkexpr(vA))),
16045 putVReg( vD_addr, binop(Iop_Add8x16, mkexpr(vA), mkexpr(vB)) );
16050 putVReg( vD_addr, binop(Iop_Add16x8, mkexpr(vA), mkexpr(vB)) );
16055 putVReg( vD_addr, binop(Iop_Add32x4, mkexpr(vA), mkexpr(vB)) );
16060 putVReg( vD_addr, binop(Iop_Add64x2, mkexpr(vA), mkexpr(vB)) );
16065 putVReg( vD_addr, binop(Iop_QAdd8Ux16, mkexpr(vA), mkexpr(vB)) );
16071 putVReg( vD_addr, binop(Iop_QAdd16Ux8, mkexpr(vA), mkexpr(vB)) );
16077 putVReg( vD_addr, binop(Iop_QAdd32Ux4, mkexpr(vA), mkexpr(vB)) );
16083 putVReg( vD_addr, binop(Iop_QAdd8Sx16, mkexpr(vA), mkexpr(vB)) );
16089 putVReg( vD_addr, binop(Iop_QAdd16Sx8, mkexpr(vA), mkexpr(vB)) );
16095 putVReg( vD_addr, binop(Iop_QAdd32Sx4, mkexpr(vA), mkexpr(vB)) );
16106 binop(Iop_CmpGT32Ux4, mkexpr(vB),
16107 mkexpr(vA))),
16113 putVReg( vD_addr, binop(Iop_Sub8x16, mkexpr(vA), mkexpr(vB)) );
16118 putVReg( vD_addr, binop(Iop_Sub16x8, mkexpr(vA), mkexpr(vB)) );
16123 putVReg( vD_addr, binop(Iop_Sub32x4, mkexpr(vA), mkexpr(vB)) );
16128 putVReg( vD_addr, binop(Iop_Sub64x2, mkexpr(vA), mkexpr(vB)) );
16133 putVReg( vD_addr, binop(Iop_QSub8Ux16, mkexpr(vA), mkexpr(vB)) );
16139 putVReg( vD_addr, binop(Iop_QSub16Ux8, mkexpr(vA), mkexpr(vB)) );
16145 putVReg( vD_addr, binop(Iop_QSub32Ux4, mkexpr(vA), mkexpr(vB)) );
16151 putVReg( vD_addr, binop(Iop_QSub8Sx16, mkexpr(vA), mkexpr(vB)) );
16157 putVReg( vD_addr, binop(Iop_QSub16Sx8, mkexpr(vA), mkexpr(vB)) );
16163 putVReg( vD_addr, binop(Iop_QSub32Sx4, mkexpr(vA), mkexpr(vB)) );
16171 putVReg( vD_addr, binop(Iop_Max8Ux16, mkexpr(vA), mkexpr(vB)) );
16176 putVReg( vD_addr, binop(Iop_Max16Ux8, mkexpr(vA), mkexpr(vB)) );
16181 putVReg( vD_addr, binop(Iop_Max32Ux4, mkexpr(vA), mkexpr(vB)) );
16186 putVReg( vD_addr, binop(Iop_Max64Ux2, mkexpr(vA), mkexpr(vB)) );
16191 putVReg( vD_addr, binop(Iop_Max8Sx16, mkexpr(vA), mkexpr(vB)) );
16196 putVReg( vD_addr, binop(Iop_Max16Sx8, mkexpr(vA), mkexpr(vB)) );
16201 putVReg( vD_addr, binop(Iop_Max32Sx4, mkexpr(vA), mkexpr(vB)) );
16206 putVReg( vD_addr, binop(Iop_Max64Sx2, mkexpr(vA), mkexpr(vB)) );
16212 putVReg( vD_addr, binop(Iop_Min8Ux16, mkexpr(vA), mkexpr(vB)) );
16217 putVReg( vD_addr, binop(Iop_Min16Ux8, mkexpr(vA), mkexpr(vB)) );
16222 putVReg( vD_addr, binop(Iop_Min32Ux4, mkexpr(vA), mkexpr(vB)) );
16227 putVReg( vD_addr, binop(Iop_Min64Ux2, mkexpr(vA), mkexpr(vB)) );
16232 putVReg( vD_addr, binop(Iop_Min8Sx16, mkexpr(vA), mkexpr(vB)) );
16237 putVReg( vD_addr, binop(Iop_Min16Sx8, mkexpr(vA), mkexpr(vB)) );
16242 putVReg( vD_addr, binop(Iop_Min32Sx4, mkexpr(vA), mkexpr(vB)) );
16247 putVReg( vD_addr, binop(Iop_Min64Sx2, mkexpr(vA), mkexpr(vB)) );
16254 putVReg( vD_addr, binop(Iop_Avg8Ux16, mkexpr(vA), mkexpr(vB)) );
16259 putVReg( vD_addr, binop(Iop_Avg16Ux8, mkexpr(vA), mkexpr(vB)) );
16264 putVReg( vD_addr, binop(Iop_Avg32Ux4, mkexpr(vA), mkexpr(vB)) );
16269 putVReg( vD_addr, binop(Iop_Avg8Sx16, mkexpr(vA), mkexpr(vB)) );
16274 putVReg( vD_addr, binop(Iop_Avg16Sx8, mkexpr(vA), mkexpr(vB)) );
16279 putVReg( vD_addr, binop(Iop_Avg32Sx4, mkexpr(vA), mkexpr(vB)) );
16287 binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)));
16293 binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)));
16298 putVReg( vD_addr, binop( Iop_MullEven32Ux4, mkexpr(vA), mkexpr(vB) ) );
16303 putVReg( vD_addr, binop( Iop_Mul32x4, mkexpr(vA), mkexpr(vB) ) );
16309 binop(Iop_MullEven8Sx16, mkexpr(vA), mkexpr(vB)));
16315 binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)));
16320 putVReg( vD_addr, binop( Iop_MullEven32Sx4, mkexpr(vA), mkexpr(vB) ) );
16325 putVReg( vD_addr, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
16330 putVReg( vD_addr, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
16335 putVReg( vD_addr, MK_Iop_MullOdd32Ux4( mkexpr(vA), mkexpr(vB) ) );
16340 putVReg( vD_addr, MK_Iop_MullOdd8Sx16( mkexpr(vA), mkexpr(vB) ));
16345 putVReg( vD_addr, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
16350 putVReg( vD_addr, MK_Iop_MullOdd32Sx4( mkexpr(vA), mkexpr(vB) ) );
16360 expand8Ux16( mkexpr(vA), &aEvn, &aOdd ); // (15,13...),(14,12...)
16361 expand16Ux8( mkexpr(aEvn), &aEE, &aEO ); // (15,11...),(13, 9...)
16362 expand16Ux8( mkexpr(aOdd), &aOE, &aOO ); // (14,10...),(12, 8...)
16365 breakV128to4x64U( mkexpr(aEE), &a15, &a11, &a7, &a3 );
16366 breakV128to4x64U( mkexpr(aOE), &a14, &a10, &a6, &a2 );
16367 breakV128to4x64U( mkexpr(aEO), &a13, &a9, &a5, &a1 );
16368 breakV128to4x64U( mkexpr(aOO), &a12, &a8, &a4, &a0 );
16369 breakV128to4x64U( mkexpr(vB), &b3, &b2, &b1, &b0 );
16372 assign( z3, binop(Iop_Add64, mkexpr(b3),
16374 binop(Iop_Add64, mkexpr(a15), mkexpr(a14)),
16375 binop(Iop_Add64, mkexpr(a13), mkexpr(a12)))) );
16376 assign( z2, binop(Iop_Add64, mkexpr(b2),
16378 binop(Iop_Add64, mkexpr(a11), mkexpr(a10)),
16379 binop(Iop_Add64, mkexpr(a9), mkexpr(a8)))) );
16380 assign( z1, binop(Iop_Add64, mkexpr(b1),
16382 binop(Iop_Add64, mkexpr(a7), mkexpr(a6)),
16383 binop(Iop_Add64, mkexpr(a5), mkexpr(a4)))) );
16384 assign( z0, binop(Iop_Add64, mkexpr(b0),
16386 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
16387 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
16390 putVReg( vD_addr, mkV128from4x64U( mkexpr(z3), mkexpr(z2),
16391 mkexpr(z1), mkexpr(z0)) );
16400 expand8Sx16( mkexpr(vA), &aEvn, &aOdd ); // (15,13...),(14,12...)
16401 expand16Sx8( mkexpr(aEvn), &aEE, &aEO ); // (15,11...),(13, 9...)
16402 expand16Sx8( mkexpr(aOdd), &aOE, &aOO ); // (14,10...),(12, 8...)
16405 breakV128to4x64S( mkexpr(aEE), &a15, &a11, &a7, &a3 );
16406 breakV128to4x64S( mkexpr(aOE), &a14, &a10, &a6, &a2 );
16407 breakV128to4x64S( mkexpr(aEO), &a13, &a9, &a5, &a1 );
16408 breakV128to4x64S( mkexpr(aOO), &a12, &a8, &a4, &a0 );
16409 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
16412 assign( z3, binop(Iop_Add64, mkexpr(b3),
16414 binop(Iop_Add64, mkexpr(a15), mkexpr(a14)),
16415 binop(Iop_Add64, mkexpr(a13), mkexpr(a12)))) );
16416 assign( z2, binop(Iop_Add64, mkexpr(b2),
16418 binop(Iop_Add64, mkexpr(a11), mkexpr(a10)),
16419 binop(Iop_Add64, mkexpr(a9), mkexpr(a8)))) );
16420 assign( z1, binop(Iop_Add64, mkexpr(b1),
16422 binop(Iop_Add64, mkexpr(a7), mkexpr(a6)),
16423 binop(Iop_Add64, mkexpr(a5), mkexpr(a4)))) );
16424 assign( z0, binop(Iop_Add64, mkexpr(b0),
16426 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
16427 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
16430 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
16431 mkexpr(z1), mkexpr(z0)) );
16438 expand16Sx8( mkexpr(vA), &aEvn, &aOdd ); // (7,5...),(6,4...)
16441 breakV128to4x64S( mkexpr(aEvn), &a7, &a5, &a3, &a1 );
16442 breakV128to4x64S( mkexpr(aOdd), &a6, &a4, &a2, &a0 );
16443 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
16446 assign( z3, binop(Iop_Add64, mkexpr(b3),
16447 binop(Iop_Add64, mkexpr(a7), mkexpr(a6))));
16448 assign( z2, binop(Iop_Add64, mkexpr(b2),
16449 binop(Iop_Add64, mkexpr(a5), mkexpr(a4))));
16450 assign( z1, binop(Iop_Add64, mkexpr(b1),
16451 binop(Iop_Add64, mkexpr(a3), mkexpr(a2))));
16452 assign( z0, binop(Iop_Add64, mkexpr(b0),
16453 binop(Iop_Add64, mkexpr(a1), mkexpr(a0))));
16456 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
16457 mkexpr(z1), mkexpr(z0)) );
16464 breakV128to4x64S( mkexpr(vA), &a3, &a2, &a1, &a0 );
16465 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
16468 assign( z2, binop(Iop_Add64, mkexpr(b2),
16469 binop(Iop_Add64, mkexpr(a3), mkexpr(a2))) );
16470 assign( z0, binop(Iop_Add64, mkexpr(b0),
16471 binop(Iop_Add64, mkexpr(a1), mkexpr(a0))) );
16474 putVReg( vD_addr, mkV128from4x64S( mkU64(0), mkexpr(z2),
16475 mkU64(0), mkexpr(z0)) );
16482 breakV128to4x64S( mkexpr(vA), &a3, &a2, &a1, &a0 );
16483 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
16486 assign( z0, binop(Iop_Add64, mkexpr(b0),
16488 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
16489 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
16493 mkU64(0), mkexpr(z0)) );
16528 putVReg( vD_addr, binop(Iop_AndV128, mkexpr(vA), mkexpr(vB)) );
16533 putVReg( vD_addr, binop(Iop_AndV128, mkexpr(vA),
16534 unop(Iop_NotV128, mkexpr(vB))) );
16539 putVReg( vD_addr, binop(Iop_OrV128, mkexpr(vA), mkexpr(vB)) );
16544 putVReg( vD_addr, binop(Iop_XorV128, mkexpr(vA), mkexpr(vB)) );
16550 unop(Iop_NotV128, binop(Iop_OrV128, mkexpr(vA), mkexpr(vB))) );
16556 mkexpr( vA ),
16557 unop( Iop_NotV128, mkexpr( vB ) ) ) );
16563 binop(Iop_AndV128, mkexpr( vA ),
16564 mkexpr( vB ) ) ) );
16570 binop( Iop_XorV128, mkexpr( vA ),
16571 mkexpr( vB ) ) ) );
16609 assign( vD, binop(Iop_CmpEQ8x16, mkexpr(vA), mkexpr(vB)) );
16615 assign( vD, binop(Iop_CmpEQ16x8, mkexpr(vA), mkexpr(vB)) );
16621 assign( vD, binop(Iop_CmpEQ32x4, mkexpr(vA), mkexpr(vB)) );
16627 assign( vD, binop(Iop_CmpEQ64x2, mkexpr(vA), mkexpr(vB)) );
16633 assign( vD, binop(Iop_CmpGT8Ux16, mkexpr(vA), mkexpr(vB)) );
16639 assign( vD, binop(Iop_CmpGT16Ux8, mkexpr(vA), mkexpr(vB)) );
16645 assign( vD, binop(Iop_CmpGT32Ux4, mkexpr(vA), mkexpr(vB)) );
16651 assign( vD, binop(Iop_CmpGT64Ux2, mkexpr(vA), mkexpr(vB)) );
16657 assign( vD, binop(Iop_CmpGT8Sx16, mkexpr(vA), mkexpr(vB)) );
16663 assign( vD, binop(Iop_CmpGT16Sx8, mkexpr(vA), mkexpr(vB)) );
16669 assign( vD, binop(Iop_CmpGT32Sx4, mkexpr(vA), mkexpr(vB)) );
16675 assign( vD, binop(Iop_CmpGT64Sx2, mkexpr(vA), mkexpr(vB)) );
16683 putVReg( vD_addr, mkexpr(vD) );
16686 set_AV_CR6( mkexpr(vD), True );
16744 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)));
16745 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16746 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16747 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
16748 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16749 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16750 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
16752 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
16755 mkexpr(aLo), mkexpr(bLo)),
16758 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
16761 mkexpr(aHi), mkexpr(bHi)),
16765 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(zHi), mkexpr(zLo)) );
16773 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)) );
16774 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16775 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16776 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
16777 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16778 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16779 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
16785 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
16787 binop(Iop_Add32x4, mkexpr(zKonst),
16789 mkexpr(aLo), mkexpr(bLo))),
16792 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
16794 binop(Iop_Add32x4, mkexpr(zKonst),
16796 mkexpr(aHi), mkexpr(bHi))),
16800 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(zHi), mkexpr(zLo)) );
16806 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16807 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16808 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vC)));
16809 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16810 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16811 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vC)));
16813 binop(Iop_MullEven16Ux8, mkexpr(aLo), mkexpr(bLo)),
16814 mkexpr(cLo)) );
16816 binop(Iop_MullEven16Ux8, mkexpr(aHi), mkexpr(bHi)),
16817 mkexpr(cHi)));
16819 binop(Iop_NarrowBin32to16x8, mkexpr(zHi), mkexpr(zLo)) );
16832 assign( abEvn, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
16833 assign( abOdd, binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)) );
16836 expand16Ux8( mkexpr(abEvn), &abEE, &abEO );
16837 expand16Ux8( mkexpr(abOdd), &abOE, &abOO );
16840 binop(Iop_Add32x4, mkexpr(vC),
16842 binop(Iop_Add32x4, mkexpr(abEE), mkexpr(abEO)),
16843 binop(Iop_Add32x4, mkexpr(abOE), mkexpr(abOO)))) );
16858 expand8Sx16( mkexpr(vA), &aEvn, &aOdd );
16859 expand8Ux16( mkexpr(vB), &bEvn, &bOdd );
16862 assign( abEE, MK_Iop_MullOdd16Sx8( mkexpr(aEvn), mkexpr(bEvn) ));
16863 assign( abEO, binop(Iop_MullEven16Sx8, mkexpr(aEvn), mkexpr(bEvn)) );
16864 assign( abOE, MK_Iop_MullOdd16Sx8( mkexpr(aOdd), mkexpr(bOdd) ));
16865 assign( abOO, binop(Iop_MullEven16Sx8, mkexpr(aOdd), mkexpr(bOdd)) );
16869 binop(Iop_QAdd32Sx4, mkexpr(vC),
16871 binop(Iop_QAdd32Sx4, mkexpr(abEE), mkexpr(abEO)),
16872 binop(Iop_QAdd32Sx4, mkexpr(abOE), mkexpr(abOO)))) );
16878 assign( abEvn, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
16879 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
16881 binop(Iop_Add32x4, mkexpr(vC),
16882 binop(Iop_Add32x4, mkexpr(abEvn), mkexpr(abOdd))) );
16889 assign( abEvn, MK_Iop_MullOdd16Ux8(mkexpr(vA), mkexpr(vB) ));
16890 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
16893 breakV128to4x64U( mkexpr(abEvn), &ab7, &ab5, &ab3, &ab1 );
16894 breakV128to4x64U( mkexpr(abOdd), &ab6, &ab4, &ab2, &ab0 );
16895 breakV128to4x64U( mkexpr(vC), &c3, &c2, &c1, &c0 );
16898 assign( z3, binop(Iop_Add64, mkexpr(c3),
16899 binop(Iop_Add64, mkexpr(ab7), mkexpr(ab6))));
16900 assign( z2, binop(Iop_Add64, mkexpr(c2),
16901 binop(Iop_Add64, mkexpr(ab5), mkexpr(ab4))));
16902 assign( z1, binop(Iop_Add64, mkexpr(c1),
16903 binop(Iop_Add64, mkexpr(ab3), mkexpr(ab2))));
16904 assign( z0, binop(Iop_Add64, mkexpr(c0),
16905 binop(Iop_Add64, mkexpr(ab1), mkexpr(ab0))));
16908 putVReg( vD_addr, mkV128from4x64U( mkexpr(z3), mkexpr(z2),
16909 mkexpr(z1), mkexpr(z0)) );
16916 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
16917 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
16919 binop(Iop_Add32x4, mkexpr(vC),
16920 binop(Iop_Add32x4, mkexpr(abOdd), mkexpr(abEvn))) );
16927 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
16928 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
16931 breakV128to4x64S( mkexpr(abEvn), &ab7, &ab5, &ab3, &ab1 );
16932 breakV128to4x64S( mkexpr(abOdd), &ab6, &ab4, &ab2, &ab0 );
16933 breakV128to4x64S( mkexpr(vC), &c3, &c2, &c1, &c0 );
16936 assign( z3, binop(Iop_Add64, mkexpr(c3),
16937 binop(Iop_Add64, mkexpr(ab7), mkexpr(ab6))));
16938 assign( z2, binop(Iop_Add64, mkexpr(c2),
16939 binop(Iop_Add64, mkexpr(ab5), mkexpr(ab4))));
16940 assign( z1, binop(Iop_Add64, mkexpr(c1),
16941 binop(Iop_Add64, mkexpr(ab3), mkexpr(ab2))));
16942 assign( z0, binop(Iop_Add64, mkexpr(c0),
16943 binop(Iop_Add64, mkexpr(ab1), mkexpr(ab0))));
16946 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
16947 mkexpr(z1), mkexpr(z0)) );
16987 mkexpr(vA), mkexpr(vB)) );
16992 mkexpr(vA), mkexpr(vB)) );
16997 mkexpr(vA), mkexpr(vB)) );
17002 mkexpr(vA), mkexpr(vB)) );
17037 putVReg( vD_addr, binop(Iop_Rol8x16, mkexpr(vA), mkexpr(vB)) );
17042 putVReg( vD_addr, binop(Iop_Rol16x8, mkexpr(vA), mkexpr(vB)) );
17047 putVReg( vD_addr, binop(Iop_Rol32x4, mkexpr(vA), mkexpr(vB)) );
17052 putVReg( vD_addr, binop(Iop_Rol64x2, mkexpr(vA), mkexpr(vB)) );
17059 putVReg( vD_addr, binop(Iop_Shl8x16, mkexpr(vA), mkexpr(vB)) );
17064 putVReg( vD_addr, binop(Iop_Shl16x8, mkexpr(vA), mkexpr(vB)) );
17069 putVReg( vD_addr, binop(Iop_Shl32x4, mkexpr(vA), mkexpr(vB)) );
17074 putVReg( vD_addr, binop(Iop_Shl64x2, mkexpr(vA), mkexpr(vB)) );
17082 unop(Iop_V128to32, mkexpr(vB)))) );
17084 binop(Iop_ShlV128, mkexpr(vA), mkexpr(sh)) );
17092 unop(Iop_V128to32, mkexpr(vB)))) );
17094 binop(Iop_ShlV128, mkexpr(vA), mkexpr(sh)) );
17102 putVReg( vD_addr, binop(Iop_Shr8x16, mkexpr(vA), mkexpr(vB)) );
17107 putVReg( vD_addr, binop(Iop_Shr16x8, mkexpr(vA), mkexpr(vB)) );
17112 putVReg( vD_addr, binop(Iop_Shr32x4, mkexpr(vA), mkexpr(vB)) );
17120 unop(Iop_V128to32, mkexpr(vB)))) );
17122 binop(Iop_ShrV128, mkexpr(vA), mkexpr(sh)) );
17127 putVReg( vD_addr, binop(Iop_Sar8x16, mkexpr(vA), mkexpr(vB)) );
17132 putVReg( vD_addr, binop(Iop_Sar16x8, mkexpr(vA), mkexpr(vB)) );
17137 putVReg( vD_addr, binop(Iop_Sar32x4, mkexpr(vA), mkexpr(vB)) );
17142 putVReg( vD_addr, binop(Iop_Sar64x2, mkexpr(vA), mkexpr(vB)) );
17150 unop(Iop_V128to32, mkexpr(vB)))) );
17152 binop(Iop_ShrV128, mkexpr(vA), mkexpr(sh)) );
17158 putVReg( vD_addr, binop(Iop_Shr64x2, mkexpr(vA), mkexpr(vB)) );
17204 binop(Iop_AndV128, mkexpr(vA), unop(Iop_NotV128, mkexpr(vC))),
17205 binop(Iop_AndV128, mkexpr(vB), mkexpr(vC))) );
17220 binop(Iop_AndV128, mkexpr(vC),
17223 binop(Iop_Perm8x16, mkexpr(vA), mkexpr(vC_andF)) );
17225 binop(Iop_Perm8x16, mkexpr(vB), mkexpr(vC_andF)) );
17228 binop(Iop_ShlN8x16, mkexpr(vC), mkU8(3)),
17232 binop(Iop_AndV128, mkexpr(a_perm),
17233 unop(Iop_NotV128, mkexpr(mask))),
17234 binop(Iop_AndV128, mkexpr(b_perm),
17235 mkexpr(mask))) );
17246 putVReg( vD_addr, mkexpr(vA) );
17250 binop(Iop_ShlV128, mkexpr(vA), mkU8(SHB_uimm4*8)),
17251 binop(Iop_ShrV128, mkexpr(vB), mkU8((16-SHB_uimm4)*8))) );
17260 assign( vrc_b, binop( Iop_AndV128, mkexpr( vC ),
17263 binop( Iop_AndV128, mkexpr( vC ),
17266 assign( a_perm, binop( Iop_Perm8x16, mkexpr( vA ), mkexpr( vrc_a ) ) );
17267 assign( b_perm, binop( Iop_Perm8x16, mkexpr( vB ), mkexpr( vrc_b ) ) );
17269 mkexpr( a_perm ), mkexpr( b_perm) ) );
17283 binop(Iop_InterleaveHI8x16, mkexpr(vA), mkexpr(vB)) );
17289 binop(Iop_InterleaveHI16x8, mkexpr(vA), mkexpr(vB)) );
17295 binop(Iop_InterleaveHI32x4, mkexpr(vA), mkexpr(vB)) );
17301 binop(Iop_InterleaveLO8x16, mkexpr(vA), mkexpr(vB)) );
17307 binop(Iop_InterleaveLO16x8, mkexpr(vA), mkexpr(vB)) );
17313 binop(Iop_InterleaveLO32x4, mkexpr(vA), mkexpr(vB)) );
17324 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm))))) );
17332 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm))))) );
17341 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm)))) );
17369 binop(Iop_CatOddLanes32x4, mkexpr(vA), mkexpr(vB) ) );
17380 binop(Iop_CatEvenLanes32x4, mkexpr(vA), mkexpr(vB) ) );
17418 binop(Iop_NarrowBin16to8x16, mkexpr(vA), mkexpr(vB)) );
17424 binop(Iop_NarrowBin32to16x8, mkexpr(vA), mkexpr(vB)) );
17430 binop(Iop_QNarrowBin16Uto8Ux16, mkexpr(vA), mkexpr(vB)) );
17437 binop(Iop_QNarrowBin32Uto16Ux8, mkexpr(vA), mkexpr(vB)) );
17448 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17451 mkexpr(vA), mkU8(15)))) );
17452 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17455 mkexpr(vB), mkU8(15)))) );
17457 mkexpr(vA_tmp), mkexpr(vB_tmp)) );
17468 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17471 mkexpr(vA), mkU8(31)))) );
17472 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17475 mkexpr(vB), mkU8(31)))) );
17477 mkexpr(vA_tmp), mkexpr(vB_tmp)) );
17484 binop(Iop_QNarrowBin16Sto8Sx16, mkexpr(vA), mkexpr(vB)) );
17491 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(vA), mkexpr(vB)) );
17508 binop(Iop_ShrN32x4, mkexpr(vA), mkU8(19)),
17511 binop(Iop_ShrN16x8, mkexpr(vA), mkU8(11)),
17514 binop(Iop_ShlN16x8, mkexpr(vA), mkU8(8)),
17516 assign( a_tmp, binop(Iop_OrV128, mkexpr(a1),
17517 binop(Iop_OrV128, mkexpr(a2), mkexpr(a3))) );
17520 binop(Iop_ShrN32x4, mkexpr(vB), mkU8(19)),
17523 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(11)),
17526 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(8)),
17528 assign( b_tmp, binop(Iop_OrV128, mkexpr(b1),
17529 binop(Iop_OrV128, mkexpr(b2), mkexpr(b3))) );
17532 mkexpr(a_tmp), mkexpr(b_tmp)) );
17539 binop(Iop_NarrowBin64to32x4, mkexpr(vA), mkexpr(vB)) );
17545 binop(Iop_QNarrowBin64Uto32Ux4, mkexpr(vA), mkexpr(vB)) );
17558 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17561 mkexpr(vA), mkU8(63)))) );
17562 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17565 mkexpr(vB), mkU8(63)))) );
17567 mkexpr(vA_tmp), mkexpr(vB_tmp)) );
17575 binop(Iop_QNarrowBin64Sto32Sx4, mkexpr(vA), mkexpr(vB)) );
17596 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
17598 binop(Iop_InterleaveHI8x16, mkexpr(signs), mkexpr(vB)) );
17603 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
17605 binop(Iop_InterleaveHI16x8, mkexpr(signs), mkexpr(vB)) );
17610 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
17612 binop(Iop_InterleaveLO8x16, mkexpr(signs), mkexpr(vB)) );
17617 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
17619 binop(Iop_InterleaveLO16x8, mkexpr(signs), mkexpr(vB)) );
17633 binop(Iop_SarN16x8, mkexpr(vB), mkU8(15)),
17636 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(1)),
17638 assign( z01, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
17639 binop(Iop_OrV128, mkexpr(z0), mkexpr(z1))) );
17642 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(5)),
17646 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(11)),
17648 assign( z23, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
17649 binop(Iop_OrV128, mkexpr(z2), mkexpr(z3))) );
17652 binop(Iop_ShlN32x4, mkexpr(z01), mkU8(16)),
17653 mkexpr(z23)) );
17666 binop(Iop_SarN16x8, mkexpr(vB), mkU8(15)),
17669 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(1)),
17671 assign( z01, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
17672 binop(Iop_OrV128, mkexpr(z0), mkexpr(z1))) );
17675 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(5)),
17679 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(11)),
17681 assign( z23, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
17682 binop(Iop_OrV128, mkexpr(z2), mkexpr(z3))) );
17685 binop(Iop_ShlN32x4, mkexpr(z01), mkU8(16)),
17686 mkexpr(z23)) );
17691 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
17693 binop(Iop_InterleaveHI32x4, mkexpr(signs), mkexpr(vB)) );
17698 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
17700 binop(Iop_InterleaveLO32x4, mkexpr(signs), mkexpr(vB)) );
17735 binop(Iop_CipherV128, mkexpr(vA), mkexpr(vB)) );
17741 binop(Iop_CipherLV128, mkexpr(vA), mkexpr(vB)) );
17747 binop(Iop_NCipherV128, mkexpr(vA), mkexpr(vB)) );
17753 binop(Iop_NCipherLV128, mkexpr(vA), mkexpr(vB)) );
17761 unop(Iop_CipherSV128, mkexpr(vA) ) );
17797 assign( dst, binop( Iop_SHA256, mkexpr( vA ), mkU8( s_field) ) );
17798 putVReg( vRT_addr, mkexpr(dst));
17803 putVReg( vRT_addr, binop( Iop_SHA512, mkexpr( vA ), mkU8( s_field) ) );
17865 mkexpr(_vecA_32),
17866 mkexpr(_vecB_32) ),
17867 (i == 0) ? mkU32(0) : mkexpr(carry) ),
17874 mkU64(0) ) : mkexpr(tmp_result),
17880 mkexpr(res_32) ) ),
17883 assign(tmp_result, mkexpr(result));
17887 mkexpr(res_32),
17888 mkexpr(_vecA_32 ) ) ) );
17923 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
17924 mkexpr(vB),
17929 putVReg( vRT_addr, mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
17930 mkexpr(vB), mkU32(0), True) ) );
17936 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
17938 mkexpr(vB) ),
17944 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
17945 unop( Iop_NotV128, mkexpr(vB) ),
17953 IRExpr * vB_expr = mkexpr(vB);
17973 mkexpr(idx_tmp),
17983 mkexpr(idx_LT127) ),
17985 unop( Iop_V128to32, mkexpr( idx_tmp ) ) ) ) );
17991 unop( Iop_1Uto32, mkexpr(idx_LT127 ) ) ) ) );
17994 mkexpr( idx_LT127_ity128 ),
18001 mkexpr( vA ),
18002 mkexpr( idx ) ) ),
18007 mkexpr( perm_bit ),
18032 unop( Iop_V128to64, mkexpr(vC) ) ),
18036 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA), mkexpr(vB),
18037 mkexpr(cin),
18046 unop( Iop_V128to64, mkexpr(vC) ) ),
18049 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA), mkexpr(vB),
18050 mkexpr(cin),
18059 unop( Iop_V128to64, mkexpr(vC) ) ),
18063 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
18065 mkexpr(vB) ),
18066 mkexpr(cin),
18075 unop( Iop_V128to64, mkexpr(vC) ) ),
18078 mkexpr(_get_quad_modulo_or_carry(mkexpr(vA),
18079 unop( Iop_NotV128, mkexpr(vB) ),
18080 mkexpr(cin),
18123 assign( dst, triop( Iop_BCDAdd, mkexpr( vA ),
18124 mkexpr( vB ), mkU8( ps ) ) );
18125 putVReg( vRT_addr, mkexpr(dst));
18130 assign( dst, triop( Iop_BCDSub, mkexpr( vA ),
18131 mkexpr( vB ), mkU8( ps ) ) );
18132 putVReg( vRT_addr, mkexpr(dst));
18177 mkexpr(vB),
18179 mkexpr(vA), mkexpr(vC))) );
18187 mkexpr(vB),
18189 mkexpr(vA), mkexpr(vC))) );
18202 mkU32(Irrm_NEAREST), mkexpr(vA), mkexpr(vB)) );
18208 mkU32(Irrm_NEAREST), mkexpr(vA), mkexpr(vB)) );
18213 putVReg( vD_addr, binop(Iop_Max32Fx4, mkexpr(vA), mkexpr(vB)) );
18218 putVReg( vD_addr, binop(Iop_Min32Fx4, mkexpr(vA), mkexpr(vB)) );
18234 putVReg( vD_addr, unop(Iop_RecipEst32Fx4, mkexpr(vB)) );
18239 putVReg( vD_addr, unop(Iop_RSqrtEst32Fx4, mkexpr(vB)) );
18289 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
18295 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
18301 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
18322 binop(Iop_CmpLE32Fx4, mkexpr(vA), mkexpr(vB))) );
18324 binop(Iop_CmpGE32Fx4, mkexpr(vA),
18326 mkexpr(zeros),
18327 mkexpr(vB)))) );
18332 binop(Iop_AndV128, mkexpr(gt),
18334 binop(Iop_AndV128, mkexpr(lt),
18345 putVReg( vD_addr, mkexpr(vD) );
18348 set_AV_CR6( mkexpr(vD), !cmp_bounds );
18389 unop(Iop_I32UtoFx4, mkexpr(vB)),
18390 mkexpr(vInvScale)) );
18397 unop(Iop_I32StoFx4, mkexpr(vB)),
18398 mkexpr(vInvScale)) );
18406 mkexpr(vB), mkexpr(vScale))) );
18414 mkexpr(vB), mkexpr(vScale))) );
18429 putVReg( vD_addr, unop(Iop_RoundF32x4_RN, mkexpr(vB)) );
18434 putVReg( vD_addr, unop(Iop_RoundF32x4_RZ, mkexpr(vB)) );
18439 putVReg( vD_addr, unop(Iop_RoundF32x4_RP, mkexpr(vB)) );
18444 putVReg( vD_addr, unop(Iop_RoundF32x4_RM, mkexpr(vB)) );
20444 // assign(n1, mkexpr(arg));
20445 // assign(n2, binop(Iop_Or32, mkexpr(n1), binop(Iop_Shr32, mkexpr(n1), mkU8(1))));
20446 // assign(n3, binop(Iop_Or32, mkexpr(n2), binop(Iop_Shr32, mkexpr(n2), mkU8(2))));
20447 // assign(n4, binop(Iop_Or32, mkexpr(n3), binop(Iop_Shr32, mkexpr(n3), mkU8(4))));
20448 // assign(n5, binop(Iop_Or32, mkexpr(n4), binop(Iop_Shr32, mkexpr(n4), mkU8(8))));
20449 // assign(n6, binop(Iop_Or32, mkexpr(n5), binop(Iop_Shr32, mkexpr(n5), mkU8(16))));
20454 // assign(n7, unop(Iop_Not32, mkexpr(n6)));
20468 // mkexpr(n7),
20470 // binop(Iop_Shr32, mkexpr(n7), mkU8(1)),
20474 // binop(Iop_And32, mkexpr(n8), mkU32(0x33333333)),
20476 // binop(Iop_Shr32, mkexpr(n8), mkU8(2)),
20481 // mkexpr(n9),
20482 // binop(Iop_Shr32, mkexpr(n9), mkU8(4))),
20486 // mkexpr(n10),
20487 // binop(Iop_Shr32, mkexpr(n10), mkU8(8))));
20490 // mkexpr(n11),
20491 // binop(Iop_Shr32, mkexpr(n11), mkU8(16))));
20493 // binop(Iop_And32, mkexpr(n12), mkU32(0x3F));