Lines Matching defs:assign
523 static void assign ( IRTemp dst, IRExpr* e )
622 assign( ones8x16, unop(Iop_Dup8x16, mkU8(0x1)) );
623 assign( *vOdd, binop(Iop_MullEven8Ux16, mkexpr(ones8x16), vIn) );
624 assign( *vEvn, binop(Iop_MullEven8Ux16, mkexpr(ones8x16),
640 assign( ones8x16, unop(Iop_Dup8x16, mkU8(0x1)) );
641 assign( *vOdd, binop(Iop_MullEven8Sx16, mkexpr(ones8x16), vIn) );
642 assign( *vEvn, binop(Iop_MullEven8Sx16, mkexpr(ones8x16),
658 assign( ones16x8, unop(Iop_Dup16x8, mkU16(0x1)) );
659 assign( *vOdd, binop(Iop_MullEven16Ux8, mkexpr(ones16x8), vIn) );
660 assign( *vEvn, binop(Iop_MullEven16Ux8, mkexpr(ones16x8),
676 assign( ones16x8, unop(Iop_Dup16x8, mkU16(0x1)) );
677 assign( *vOdd, binop(Iop_MullEven16Sx8, mkexpr(ones16x8), vIn) );
678 assign( *vEvn, binop(Iop_MullEven16Sx8, mkexpr(ones16x8),
701 assign( hi64, unop(Iop_V128HIto64, t128) );
702 assign( lo64, unop(Iop_V128to64, t128) );
703 assign( *t3,
707 assign( *t2,
710 assign( *t1,
714 assign( *t0,
739 assign( hi64, unop(Iop_V128HIto64, t128) );
740 assign( lo64, unop(Iop_V128to64, t128) );
741 assign( *t3, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(hi64))) );
742 assign( *t2, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(hi64))) );
743 assign( *t1, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(lo64))) );
744 assign( *t0, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(lo64))) );
766 assign( hi64, unop(Iop_V128HIto64, t128) );
767 assign( lo64, unop(Iop_V128to64, t128) );
768 assign( *t3, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(hi64))) );
769 assign( *t2, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(hi64))) );
770 assign( *t1, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(lo64))) );
771 assign( *t0, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(lo64))) );
792 assign( hi64, unop(Iop_V128HIto64, t128) );
793 assign( lo64, unop(Iop_V128to64, t128) );
794 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
795 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
796 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
797 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
819 assign( hi32, unop(Iop_64HIto32, t64));
820 assign( lo32, unop(Iop_64to32, t64));
841 assign( hi32, unop(Iop_64HIto32, t64));
842 assign( lo32, unop(Iop_64to32, t64));
1200 assign( low, unop( Iop_D128LOtoD64, e ) );
1201 assign( high, unop( Iop_D128HItoD64, e ) );
1418 assign(mask[0], mkU32(0x55555555));
1419 assign(mask[1], mkU32(0x33333333));
1420 assign(mask[2], mkU32(0x0F0F0F0F));
1421 assign(mask[3], mkU32(0x00FF00FF));
1422 assign(mask[4], mkU32(0x0000FFFF));
1426 assign(nyu,
1446 assign( mask[0], mkU64( 0x5555555555555555ULL ) );
1447 assign( mask[1], mkU64( 0x3333333333333333ULL ) );
1448 assign( mask[2], mkU64( 0x0F0F0F0F0F0F0F0FULL ) );
1449 assign( mask[3], mkU64( 0x00FF00FF00FF00FFULL ) );
1450 assign( mask[4], mkU64( 0x0000FFFF0000FFFFULL ) );
1451 assign( mask[5], mkU64( 0x00000000FFFFFFFFULL ) );
1455 assign( nyu,
1484 assign(mask[0], mkU32(0x55555555));
1485 assign(mask[1], mkU32(0x33333333));
1486 assign(mask[2], mkU32(0x0F0F0F0F));
1487 assign(mask[3], mkU32(0x00FF00FF));
1488 assign(mask[4], mkU32(0x0000FFFF));
1492 assign(nyu1,
1506 assign(nyu2,
1516 assign(retval, unop(Iop_32Uto64, binop(Iop_Add32, mkexpr(nyu1), mkexpr(nyu2))));
1865 assign( v0, result );
1866 assign( v1, binop(Iop_ShrV128, result, mkU8(32)) );
1867 assign( v2, binop(Iop_ShrV128, result, mkU8(64)) );
1868 assign( v3, binop(Iop_ShrV128, result, mkU8(96)) );
1870 assign( rZeros, unop(Iop_1Uto8,
1880 assign( rOnes, unop(Iop_1Uto8,
2037 assign( t64, binop(Iop_MullS32, argL, argR) );
2221 assign( t128, binop(Iop_MullS64, argL, argR) );
2663 assign( val, unop( Iop_8Uto32, IRExpr_Get( OFFB_FPROUND, Ity_I8 ) ) );
2665 assign( val, mkU32(0x0) );
2956 assign( frac_part, binop( Iop_And32, mkexpr(src), mkU32(0x007fffff)) );
2972 assign( frac_part, FP_FRAC_PART(src) );
2983 assign( sign_less_part, binop( Iop_And32, mkexpr( src ), mkU32( SIGN_MASK32 ) ) );
2997 assign( sign_less_part, binop( Iop_And64, mkexpr( src ), mkU64( SIGN_MASK ) ) );
3013 assign( frac_part, FP_FRAC_PART(src) );
3055 assign(tmp, src);
3058 assign( is_SNAN,
3065 assign ( mask, binop( Iop_And32,
3086 assign( signbit_32, binop( Iop_Shr32,
3094 assign( resultantSignbit,
3102 assign( negatedResult,
3130 assign( signbit_32, binop( Iop_Shr32,
3137 assign( resultantSignbit,
3145 assign( negatedResult,
3228 assign( rA, getIReg(rA_addr) );
3229 assign( rB, getIReg(rB_addr) ); // XO-Form: rD, rA, rB
3235 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3244 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3258 assign( rD, mkSzExtendS16(ty, uimm16) );
3261 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3270 assign( rD, mkSzExtendS32(ty, uimm16 << 16) );
3273 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3281 assign( rD, unop(Iop_128to64,
3285 assign( rD, unop(Iop_64to32,
3293 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
3310 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3322 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3339 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3340 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3365 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3367 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3391 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3392 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3418 assign( rD, mk64lo32Uto64( binop(Iop_DivS64, dividend,
3425 assign( rD, binop(Iop_DivS32, mkexpr(rA), mkexpr(rB)) );
3449 assign( rD, mk64lo32Uto64( binop(Iop_DivU64, dividend,
3456 assign( rD, binop(Iop_DivU32, mkexpr(rA), mkexpr(rB)) );
3475 assign( rD, binop(Iop_Sar64,
3481 assign( rD, unop(Iop_64HIto32,
3497 assign( rD, binop(Iop_Sar64,
3503 assign( rD, unop(Iop_64HIto32,
3518 assign( rD, binop(Iop_MullS32, a, b) );
3525 assign( rD, unop(Iop_64to32,
3544 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3558 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
3571 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
3588 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3589 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3615 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3617 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3642 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA32(), False) );
3643 assign( rD, binop( mkSzOp(ty, Iop_Add8),
3665 assign( rD, unop(Iop_128HIto64,
3678 assign( rD, unop(Iop_128HIto64,
3687 assign( rD, binop(Iop_Mul64, mkexpr(rA), mkexpr(rB)) );
3698 assign( rD, binop(Iop_DivS64, mkexpr(rA), mkexpr(rB)) );
3713 assign( rD, binop(Iop_DivU64, mkexpr(rA), mkexpr(rB)) );
3738 assign( res, binop( Iop_DivU32E, dividend, divisor ) );
3739 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3743 assign( res, binop( Iop_DivU32E, dividend, divisor ) );
3744 assign( rD, mkexpr( res) );
3773 assign( res, binop( Iop_DivS32E, dividend, divisor ) );
3774 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3778 assign( res, binop( Iop_DivS32E, dividend, divisor ) );
3779 assign( rD, mkexpr( res) );
3802 assign( rD, binop(Iop_DivS64E, mkexpr(rA), mkexpr(rB)) );
3814 assign( rD, binop(Iop_DivU64E, mkexpr(rA), mkexpr(rB)) );
3983 assign( rS, getIReg(rS_addr) );
3984 assign( rB, getIReg(rB_addr) );
3989 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
3997 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
4005 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4011 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4017 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
4023 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
4035 assign(rA, binop( mkSzOp(ty, Iop_And8),
4042 assign(rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
4061 assign(rA, mkWidenFrom32(ty,
4067 // TODO: alternatively: assign(rA, verbose_Clz32(rS));
4074 assign( rA, unop( mkSzOp(ty, Iop_Not8),
4087 assign( rA, unop(Iop_8Sto64, unop(Iop_64to8, mkexpr(rS))) );
4089 assign( rA, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rS))) );
4100 assign( rA, unop(Iop_16Sto64,
4103 assign( rA, unop(Iop_16Sto32,
4110 assign( rA, unop( mkSzOp(ty, Iop_Not8),
4118 assign( rA, unop( mkSzOp(ty, Iop_Not8),
4126 assign( rA, mkexpr(rS) );
4130 assign( rA, binop( mkSzOp(ty, Iop_Or8),
4138 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
4145 assign( rA, binop( mkSzOp(ty, Iop_Xor8),
4157 assign(rA, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(rS))));
4169 assign(rA, IRExpr_ITE( irx,
4172 // TODO: alternatively: assign(rA, verbose_Clz64(rS));
4179 assign( rA, unop( Iop_V128to64,
4185 assign( rA, unop( Iop_V128to32,
4196 assign( frB, getFReg(rB_addr)); // always F64
4198 assign( rA, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
4200 assign( rA, unop( Iop_64to32, unop( Iop_ReinterpF64asI64, mkexpr(frB))) );
4211 assign( frA, unop( Iop_ReinterpI64asF64, mkexpr(rB)) );
4213 assign( frA, unop( Iop_ReinterpI64asF64, unop( Iop_32Uto64, mkexpr(rB))) );
4232 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4233 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4251 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4252 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4284 assign( idx_tmp,
4286 assign( idx_LT64,
4288 assign( idx,
4298 assign( idx_LT64_ity64,
4300 assign( perm_bit,
4381 assign( rS, getIReg(rS_addr) );
4386 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4387 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4388 assign( iTot2, binop(Iop_Add32,
4391 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4392 assign( iTot3, binop(Iop_Add32,
4395 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4396 assign( iTot4, binop(Iop_Add32,
4400 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4401 assign( iTot5, binop(Iop_Add32,
4404 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4405 assign( iTot6, binop(Iop_Add32,
4408 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4409 assign( iTot7, binop(Iop_Add32,
4412 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)) );
4413 assign( iTot8, binop(Iop_Add32,
4416 assign( rA, unop(Iop_32Uto64,
4419 assign( rA, mkexpr(iTot4) );
4423 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4424 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4425 assign( iTot2, binop(Iop_Add32,
4428 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4429 assign( iTot3, binop(Iop_Add32,
4432 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4433 assign( iTot4, binop(Iop_Add32,
4436 assign( iLo, unop(Iop_1Uto32, unop(Iop_32to1, mkexpr(iTot4) )) );
4439 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4440 assign( iTot5, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))) );
4441 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4442 assign( iTot6, binop(Iop_Add32,
4445 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4446 assign( iTot7, binop(Iop_Add32,
4449 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)));
4450 assign( iTot8, binop(Iop_Add32,
4453 assign( iHi, binop(Iop_And32, mkU32(1), mkexpr(iTot8)) ),
4454 assign( rA, binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo)) );
4456 assign( rA, binop(Iop_Or32, mkU32(0), mkexpr(iLo)) );
4496 assign( rS, getIReg(rS_addr) );
4497 assign( rB, getIReg(rB_addr) );
4510 assign( rot, binop(Iop_Or64, r,
4512 assign( rA,
4521 assign( rA,
4544 assign( rTmp, r );
4546 assign( rot, binop(Iop_Or64, mkexpr(rTmp),
4548 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4556 assign( rA, binop(Iop_Shl32, mkexpr(rS), mkU8(sh_imm)) );
4563 assign( rA, binop(Iop_Shr32, mkexpr(rS), mkU8(MaskBeg)) );
4571 assign( rA, binop(Iop_And32,
4593 assign(rot, binop(Iop_Or64, r, binop(Iop_Shl64, r, mkU8(32))));
4594 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4599 assign( rA, binop(Iop_And32,
4625 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
4631 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
4641 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
4648 assign(rA, r & m);
4658 assign( rA, binop(Iop_Shr64, mkexpr(rS), mkU8(msk_imm)) );
4664 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
4675 assign( rA, binop(Iop_Shl64, mkexpr(rS), mkU8(sh_imm)) );
4681 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
4691 assign( rA_orig, getIReg(rA_addr) );
4692 assign( rA, binop(Iop_Or64,
4741 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
4746 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
4751 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
4754 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
4984 assign(high, loadBE(ty, mkexpr( EA ) ) );
4985 assign(low, loadBE(ty, binop( Iop_Add64,
4989 assign(high, loadBE(ty, binop( Iop_Add32,
4992 assign(low, loadBE(ty, binop( Iop_Add32,
5031 assign( rB, getIReg(rB_addr) );
5032 assign( rS, getIReg(rS_addr) );
5036 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
5042 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
5196 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
5199 assign( EA_lo, ea_rAor0_simm( rA_addr, simm16+8 ) );
5202 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16+4 ) );
5205 assign( EA_lo, ea_rAor0_simm( rA_addr, simm16+12 ) );
5248 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
5402 assign( t_EA, ea_rAor0(rA_addr) );
5413 assign( t_nbytes, mkU32(NumBytes==0 ? 32 : NumBytes) );
5430 assign( t_EA, ea_rAor0_idxd(rA_addr,rB_addr) );
5431 assign( t_nbytes, unop( Iop_8Uto32, getXER_BC() ) );
5438 assign( t_EA, ea_rAor0(rA_addr) );
5448 assign( t_nbytes, mkU32(NumBytes==0 ? 32 : NumBytes) );
5457 assign( t_EA, ea_rAor0_idxd(rA_addr,rB_addr) );
5458 assign( t_nbytes, unop( Iop_8Uto32, getXER_BC() ) );
5487 assign( ok, mkU32(0xFFFFFFFF) );
5490 assign( ok, unop( Iop_1Sto32,
5495 assign( ok, unop( Iop_1Sto32,
5517 assign( res, mkU32(1) );
5522 assign( cr_bi, getCRbit_anywhere( BI, &where ) );
5526 assign( res, mkexpr(cr_bi) );
5531 assign( res, binop(Iop_Xor32, mkexpr(cr_bi),
5600 assign(t_tgt, mode64 ? mkU64(tgt) : mkU32(tgt) );
5630 assign( ctr_ok, branch_ctr_ok( BO ) );
5631 assign( cond_ok, branch_cond_ok( BO, BI ) );
5632 assign( do_branch,
5670 assign( cond_ok, branch_cond_ok( BO, BI ) );
5674 assign( lr_old, addr_align( getGST( PPC_GST_CTR ), 4 ));
5709 assign( ctr_ok, branch_ctr_ok( BO ) );
5710 assign( cond_ok, branch_cond_ok( BO, BI ) );
5711 assign( do_branch,
5714 assign( lr_old, addr_align( getGST( PPC_GST_LR ), 4 ));
5786 assign( crbA, getCRbit(crbA_addr) );
5790 assign( crbB, getCRbit(crbB_addr) );
5795 assign( crbD, binop(Iop_And32, mkexpr(crbA), mkexpr(crbB)) );
5799 assign( crbD, binop(Iop_And32,
5805 assign( crbD, unop(Iop_Not32,
5810 assign( crbD, unop(Iop_Not32,
5815 assign( crbD, unop(Iop_Not32,
5820 assign( crbD, binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB)) );
5824 assign( crbD, binop(Iop_Or32,
5830 assign( crbD, binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB)) );
5903 assign( argL, argL0 );
5904 assign( argR, argR0 );
6105 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
6170 assign( rS, mkNarrowTo32(ty, getIReg(rS_addr)) );
6263 assign( rS, getIReg(rS_addr) );
6330 assign( rS_hi, getIReg(rS_addr) );
6331 assign( rS_lo, getIReg(rS_addr+1) );
6395 assign( rS, getIReg(rS_addr) );
6396 assign( rB, getIReg(rB_addr) );
6397 assign( rS_lo32, mkNarrowTo32(ty, mkexpr(rS)) );
6398 assign( rB_lo32, mkNarrowTo32(ty, mkexpr(rB)) );
6422 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */False) );
6435 assign( sh_amt, binop(Iop_And32, mkU32(0x3F),
6437 assign( outofrange,
6445 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */True) );
6460 assign( rA, binop(Iop_Sar64,
6465 assign( rA, binop(Iop_Sar32, mkexpr(rS_lo32),
6498 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */False) );
6512 assign( rA,
6533 assign( sh_amt, binop(Iop_And64, mkU64(0x7F), mkexpr(rB)) );
6534 assign( outofrange,
6536 assign( rA,
6555 assign( rA, binop(Iop_Sar64, getIReg(rS_addr), mkU8(sh_imm)) );
6573 assign( rA,
6661 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
6667 assign( w1, unop(Iop_16Uto32, loadBE(Ity_I16, mkexpr(EA))) );
6668 assign( w2, gen_byterev16(w1) );
6675 assign( w1, loadBE(Ity_I32, mkexpr(EA)) );
6676 assign( w2, gen_byterev32(w1) );
6687 assign( w1, loadBE( Ity_I32, mkexpr( EA ) ) );
6688 assign( w2, gen_byterev32( w1 ) );
6691 assign( w3, loadBE( Ity_I32, nextAddr ) );
6692 assign( w4, gen_byterev32( w3 ) );
6699 assign( w1, mkNarrowTo32(ty, getIReg(rS_addr)) );
6705 assign( w1, mkNarrowTo32(ty, getIReg(rS_addr)) );
6714 assign( rS, getIReg( rS_addr ) );
6716 assign(lo, unop(Iop_64HIto32, mkexpr(rS)));
6717 assign(hi, unop(Iop_64to32, mkexpr(rS)));
6758 assign( rS, getIReg(rS_addr) );
7019 assign( vS, getVSReg( XS ) );
7041 assign( vS, getVSReg( XS ) );
7064 assign( rA, getIReg(rA_addr) );
7091 assign( rA, unop( Iop_64to32, getIReg( rA_addr ) ) );
7093 assign( rA, getIReg(rA_addr) );
7115 assign( rA, unop( Iop_64to32, getIReg( rA_addr ) ) );
7117 assign( rA, getIReg(rA_addr) );
7227 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7231 assign( addr, binop( Iop_And64,
7241 assign( addr, binop( Iop_And32,
7260 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7263 assign( addr, binop( mkSzOp(ty, Iop_And8),
7306 assign( rm_PPC32, getGST_masked( PPC_GST_FPSCR, MASK_FPSCR_RN ) );
7334 assign( rm_PPC32, getGST_masked_upper( PPC_GST_FPSCR, MASK_FPSCR_DRN ) );
7368 assign( frac_mask, unop( Iop_Not32,
7372 assign( exp_zero,
7381 assign( frac_not_zero,
7455 assign( rA, getIReg(rA_addr) );
7456 assign( rB, getIReg(rB_addr) );
7465 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
7474 assign( EA, ea_rA_simm(rA_addr, simm16) );
7482 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
7490 assign( EA, ea_rA_simm(rA_addr, simm16) );
7504 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7513 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
7521 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7529 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
7536 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
7537 assign( iLo, loadBE(Ity_I32, mkexpr(EA)) );
7538 assign( iHi, binop(Iop_Sub32,
7549 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
7550 assign( iLo, loadBE(Ity_I32, mkexpr(EA)) );
7551 assign( dw, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( iLo ) ) );
7592 assign( frS, getFReg(frS_addr) );
7593 assign( rA, getIReg(rA_addr) );
7594 assign( rB, getIReg(rB_addr) );
7605 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
7617 assign( EA, ea_rA_simm(rA_addr, simm16) );
7626 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
7634 assign( EA, ea_rA_simm(rA_addr, simm16) );
7647 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7657 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
7666 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7674 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
7682 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
7733 assign( frA, getFReg(frA_addr));
7734 assign( frB, getFReg(frB_addr));
7735 assign( frC, getFReg(frC_addr));
7745 assign( frD, triop( Iop_DivF64r32,
7754 assign( frD, triop( Iop_SubF64r32,
7763 assign( frD, triop( Iop_AddF64r32,
7775 assign( frD, binop( Iop_SqrtF64, rm, mkexpr(frB) ));
7786 assign( frD, triop( Iop_DivF64r32,
7797 assign( frD, triop( Iop_MulF64r32,
7808 assign( frD, unop(Iop_Est5FRSqrt, mkexpr(frB)) );
7824 assign( frD, triop(Iop_DivF64, rm, mkexpr(frA), mkexpr(frB)) );
7832 assign( frD, triop(Iop_SubF64, rm, mkexpr(frA), mkexpr(frB)) );
7840 assign( frD, triop(Iop_AddF64, rm, mkexpr(frA), mkexpr(frB)) );
7849 assign( frD, binop(Iop_SqrtF64, rm, mkexpr(frB)) );
7862 assign( cc, binop(Iop_CmpF64, mkexpr(frA),
7864 assign( cc_b0, binop(Iop_And32, mkexpr(cc), mkU32(1)) );
7868 assign( frD,
7889 assign( frD, triop( Iop_DivF64,
7900 assign( frD, triop(Iop_MulF64, rm, mkexpr(frA), mkexpr(frC)) );
7909 assign( frD, unop(Iop_Est5FRSqrt, mkexpr(frB)) );
7978 assign( rmt, get_IR_roundingmode() );
7981 assign( frA, getFReg(frA_addr));
7982 assign( frB, getFReg(frB_addr));
7983 assign( frC, getFReg(frC_addr));
7999 assign( frD, qop( Iop_MSubF64r32, rm,
8006 assign( frD, qop( Iop_MAddF64r32, rm,
8016 assign( tmp, qop( Iop_MSubF64r32, rm,
8021 assign( tmp, qop( Iop_MAddF64r32, rm,
8025 assign( nan_mask, Check_NaN( mkexpr( tmp ),
8027 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
8029 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
8043 assign( frD, qop( Iop_MSubF64, rm,
8050 assign( frD, qop( Iop_MAddF64, rm,
8060 assign( tmp, qop( Iop_MSubF64, rm,
8065 assign( tmp, qop( Iop_MAddF64, rm,
8069 assign( nan_mask, Check_NaN( mkexpr( tmp ),
8071 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
8073 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
8128 assign( frB_exp_shR, fp_exp_part( frB_Int, sp ) );
8129 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
8137 assign( frbInf_tmp, is_Inf(frB_Int, sp) );
8138 assign( frbZero_tmp, is_Zero(frB_Int, sp ) );
8166 assign( frac_part, binop( Iop_And32, mkexpr(frB_Int), mkU32(0x007fffff)) );
8174 assign( frac_part, FP_FRAC_PART(frB_Int) );
8196 assign (*fg_flag_tmp, fg_flag);
8197 assign (*fe_flag_tmp, fe_flag);
8252 assign( frA_exp_shR, fp_exp_part( frA_int, sp ) );
8253 assign( frB_exp_shR, fp_exp_part( frB_int, sp ) );
8255 assign(e_a, binop( Iop_Sub32, mkexpr(frA_exp_shR), mkU32( bias ) ));
8256 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
8271 assign(fraInf_tmp, is_Inf(frA_int, sp));
8282 assign( frbInf_tmp, is_Inf(frB_int, sp) );
8287 assign( frbZero_tmp, is_Zero(frB_int, sp) );
8310 assign( fraNotZero_tmp, unop( Iop_Not1, is_Zero( frA_int, sp ) ) );
8365 assign( frac_part, FP_FRAC_PART(frB_int) );
8401 assign(*fe_flag_tmp, fe_flag);
8402 assign(*fg_flag_tmp, fg_flag);
8436 assign( frB_I64, unop( Iop_ReinterpF64asI64, getFReg( frB_addr ) ) );
8449 assign( frA_I64, unop( Iop_ReinterpF64asI64, getFReg( frA_addr ) ) );
8470 assign( flags,
8512 assign( frA, getFReg(frA_addr));
8513 assign( frB, getFReg(frB_addr));
8515 assign( ccIR, binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)) );
8529 assign(
8620 assign( frB, getFReg(frB_addr));
8629 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8630 assign( frD, binop( Iop_RoundF64toF32, rm, binop( Iop_I64StoF64, rm,
8636 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8637 assign( frD, unop( Iop_F32toF64, binop( Iop_I64UtoF32, rm, mkexpr( r_tmp64 ) ) ) );
8646 assign( frD, binop( Iop_RoundF64toF32, rm, mkexpr(frB) ));
8651 assign( r_tmp32,
8653 assign( frD, unop( Iop_ReinterpI64asF64,
8661 assign( r_tmp32,
8663 assign( frD, unop( Iop_ReinterpI64asF64,
8672 assign( r_tmp32,
8676 assign( frD, unop( Iop_ReinterpI64asF64,
8685 assign( r_tmp64,
8687 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8694 assign( r_tmp64,
8696 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8705 assign( r_tmp64,
8707 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8714 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8715 assign( frD,
8721 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8722 assign( frD, binop( Iop_I64UtoF64, rm, mkexpr( r_tmp64 ) ) );
8729 assign( r_tmp64,
8734 assign( r_tmp64,
8739 assign( r_tmp64,
8744 assign( r_tmp64,
8754 assign(frD, IRExpr_ITE(
8845 assign( EA_hi, ea_rAor0_idxd( rA_addr, rB_addr ) );
8849 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
8854 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
8862 assign( EA_lo, binop(Iop_Add64, mkexpr(EA_hi), mkU64(8)) );
8864 assign( EA_lo, binop(Iop_Add32, mkexpr(EA_hi), mkU32(8)) );
8866 assign( frT_hi, getFReg(frT_hi_addr) );
8867 assign( frT_lo, getFReg(frT_lo_addr) );
8896 assign( frA, getFReg(frA_addr));
8897 assign( frB, getFReg(frB_addr));
8903 assign( frD, unop( Iop_ReinterpI64asF64,
8916 assign( frD, unop( Iop_ReinterpI64asF64,
8960 assign( frB, getFReg(frB_addr));
8970 assign( frA, getFReg(frA_addr) );
8973 assign(signA, binop(Iop_And32,
8978 assign( itmpB, unop(Iop_ReinterpF64asI64, mkexpr(frB)) );
8981 assign(hiD, binop(Iop_Or32,
8989 assign( frD, unop(Iop_ReinterpI64asF64,
8998 assign( frD, unop( Iop_NegF64, mkexpr(frB) ));
9003 assign( frD, mkexpr(frB) );
9008 assign( frD, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr(frB) )));
9013 assign( frD, unop( Iop_AbsF64, mkexpr(frB) ));
9082 assign( tmp, binop(Iop_And32,
9198 assign( frB, getFReg(frB_addr));
9199 assign( rB_64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
9279 assign( lmd_07_mask,
9281 assign( lmd_8_mask,
9283 assign( lmd_9_mask,
9285 assign( lmexp_00_mask,
9287 assign( lmexp_01_mask,
9289 assign( lmexp_10_mask,
9295 assign( lmd_07_val,
9297 assign( lmd_8_val,
9307 assign( lmd_9_val,
9359 assign( lmd_07_mask,
9363 assign( lmd_8_00_mask,
9367 assign( lmd_8_01_mask,
9371 assign( lmd_8_10_mask,
9375 assign( lmd_9_00_mask,
9379 assign( lmd_9_01_mask,
9383 assign( lmd_9_10_mask,
9391 assign( lmd_07_val, binop( Iop_And32, gfield_0_4, mkU32( 0x7 ) ) );
9392 assign( lmd_8_val, mkU32( 0x8 ) );
9393 assign( lmd_9_val, mkU32( 0x9 ) );
9395 assign( *lmd,
9421 assign( valid,
9617 assign( low_50,
9627 assign( tmplow60, unop( Iop_DPBtoBCD, mkexpr( low_50 ) ) );
9628 assign( *low_60_u, unop( Iop_64HIto32, mkexpr( tmplow60 ) ) );
9629 assign( *low_60_l, unop( Iop_64to32, mkexpr( tmplow60 ) ) );
9634 assign( mid_50,
9656 assign( tmpmid60, unop( Iop_DPBtoBCD, mkexpr( mid_50 ) ) );
9657 assign( *mid_60_u, unop( Iop_64HIto32, mkexpr( tmpmid60 ) ) );
9658 assign( *mid_60_l, unop( Iop_64to32, mkexpr( tmpmid60 ) ) );
9661 assign( top_10,
9673 assign( tmptop12, unop( Iop_DPBtoBCD, mkexpr( top_10 ) ) );
9674 assign( top_12_u, unop( Iop_64HIto32, mkexpr( tmptop12 ) ) );
9675 assign( *top_12_l, unop( Iop_64to32, mkexpr( tmptop12 ) ) );
9688 assign( cnt[start-1], init_cnt);
9689 assign( flag[start-1], init_flag);
9694 assign( cnt[i],
9710 assign( flag[i],
9736 assign( num_lmd, unop( Iop_1Uto8, binop( Iop_CmpEQ32, lmd, mkU32( 0 ) ) ) );
9737 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
9775 assign( num_lmd, unop( Iop_1Uto8, binop( Iop_CmpEQ32, lmd, mkU32( 0 ) ) ) );
9777 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
9826 assign( gfield0to5,
9879 assign( frA, getDReg( frA_addr ) );
9880 assign( frB, getDReg( frB_addr ) );
9886 assign( frS, triop( Iop_AddD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9891 assign( frS, triop( Iop_SubD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9896 assign( frS, triop( Iop_MulD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9901 assign( frS, triop( Iop_DivD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9937 assign( frA, getDReg_pair( frA_addr ) );
9938 assign( frB, getDReg_pair( frB_addr ) );
9944 assign( frS, triop( Iop_AddD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9949 assign( frS, triop( Iop_SubD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9954 assign( frS, triop( Iop_MulD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9959 assign( frS, triop( Iop_DivD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9985 assign( frA, getDReg( frA_addr ) );
9991 assign( frS, binop( Iop_ShlD64, mkexpr( frA ), mkU8( shift_val ) ) );
9996 assign( frS, binop( Iop_ShrD64, mkexpr( frA ), mkU8( shift_val ) ) );
10022 assign( frA, getDReg_pair( frA_addr ) );
10028 assign( frS, binop( Iop_ShlD128, mkexpr( frA ), mkU8( shift_val ) ) );
10033 assign( frS, binop( Iop_ShrD128, mkexpr( frA ), mkU8( shift_val ) ) );
10065 assign( frB, getDReg32( frB_addr ) );
10066 assign( frS, unop( Iop_D32toD64, mkexpr( frB ) ) );
10074 assign( frB, getDReg( frB_addr ) );
10075 assign( frS, binop( Iop_D64toD32, round, mkexpr( frB ) ) );
10086 assign( frB, getDReg( frB_addr ) );
10087 assign( tmp, binop( Iop_D64toI64S, round, mkexpr( frB ) ) );
10088 assign( frS, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10097 assign( frB, getDReg( frB_addr ) );
10098 assign( frS, binop( Iop_I64StoD64,
10130 assign( frB64, getDReg( frB_addr ) );
10131 assign( frS128, unop( Iop_D64toD128, mkexpr( frB64 ) ) );
10140 assign( frB128, getDReg_pair( frB_addr ) );
10141 assign( tmp, binop( Iop_D128toI64S, round, mkexpr( frB128 ) ) );
10142 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10149 assign( frB128, getDReg_pair( frB_addr ) );
10150 assign( frS64, binop( Iop_D128toD64, round, mkexpr( frB128 ) ) );
10161 assign( frB64, getDReg( frB_addr ) );
10162 assign( frS128, unop( Iop_I64StoD128,
10204 assign( frB, getDReg( frB_addr ) );
10205 assign( frS, binop( Iop_RoundD64toInt,
10245 assign( frB, getDReg_pair( frB_addr ) );
10246 assign( frS, binop( Iop_RoundD128toInt,
10278 assign( frB, getDReg( frB_addr ) );
10294 assign( TE_I64,
10302 assign( TE_I64,
10308 assign( frA, binop( Iop_InsertExpD64, mkexpr( TE_I64 ),
10311 assign( frS, triop( Iop_QuantizeD64,
10320 assign( frA, getDReg( frA_addr ) );
10321 assign( frS, triop( Iop_QuantizeD64,
10332 assign( frA, getDReg( frA_addr ) );
10334 assign( tmp, unop( Iop_32to8,
10338 assign( frS, triop( Iop_SignificanceRoundD64,
10372 assign( frB, getDReg_pair( frB_addr ) );
10388 assign( TE_I64,
10396 assign( TE_I64,
10403 assign( frA,
10407 assign( frS, triop( Iop_QuantizeD128,
10415 assign( frA, getDReg_pair( frA_addr ) );
10416 assign( frS, triop( Iop_QuantizeD128,
10427 assign( frA, getDReg_pair( frA_addr ) );
10428 assign( tmp, unop( Iop_32to8,
10433 assign( frS, triop( Iop_SignificanceRoundD128,
10466 assign( frA, getDReg( frA_addr ) );
10467 assign( frB, getDReg( frB_addr ) );
10473 assign( tmp, unop( Iop_ExtractExpD64, mkexpr( frB ) ) );
10474 assign( frS, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10479 assign( frS, binop( Iop_InsertExpD64,
10513 assign( frB, getDReg_pair( frB_addr ) );
10523 assign( tmp, unop( Iop_ExtractExpD128, mkexpr( frB ) ) );
10524 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
10530 assign( frA, getDReg( frA_addr ) );
10531 assign( frS, binop( Iop_InsertExpD128,
10571 assign( frA, getDReg( frA_addr ) );
10572 assign( frB, getDReg( frB_addr ) );
10574 assign( ccIR, binop( Iop_CmpD64, mkexpr( frA ), mkexpr( frB ) ) );
10581 assign( frA, getDReg_pair( frA_addr ) );
10582 assign( frB, getDReg_pair( frB_addr ) );
10583 assign( ccIR, binop( Iop_CmpD128, mkexpr( frA ), mkexpr( frB ) ) );
10600 assign( ccPPC32,
10658 assign( frA, getDReg( frA_addr ) );
10659 assign( frB, getDReg( frB_addr ) );
10660 assign( gfield_mask, mkU32( DFP_G_FIELD_LONG_MASK ) );
10661 assign(exponent_A, unop( Iop_64to32,
10664 assign(exponent_B, unop( Iop_64to32,
10671 assign( frA128, getDReg_pair( frA_addr ) );
10672 assign( frB128, getDReg_pair( frB_addr ) );
10673 assign( frA, unop( Iop_D128HItoD64, mkexpr( frA128 ) ) );
10674 assign( frB, unop( Iop_D128HItoD64, mkexpr( frB128 ) ) );
10675 assign( gfield_mask, mkU32( DFP_G_FIELD_EXTND_MASK ) );
10676 assign( exponent_A, unop( Iop_64to32,
10679 assign( exponent_B, unop( Iop_64to32,
10689 assign( gfield_A, binop( Iop_And32,
10695 assign( gfield_B, binop( Iop_And32,
10702 assign( A_NaN_true, binop(Iop_Or32,
10712 assign( B_NaN_true, binop(Iop_Or32,
10724 assign( A_inf_true,
10730 assign( B_inf_true,
10736 assign( finite_number,
10751 assign( A_equals_B,
10765 assign( cc0, binop( Iop_And32,
10774 assign( cc1, binop( Iop_And32,
10783 assign( cc2, binop( Iop_Shl32,
10789 assign( cc3, binop( Iop_And32,
10878 assign( frA, getDReg( frA_addr ) );
10879 assign( frAI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frA ) ) );
10881 assign( abs_frA, unop( Iop_ReinterpI64asD64,
10886 assign( gfield_0_4_shift, mkU8( 31 - 5 ) ); // G-field[0:4]
10892 assign( frAI64_lo, mkU64( 0 ) );
10893 assign( gfield_mask, mkU32( DFP_G_FIELD_LONG_MASK ) );
10897 assign( exponent, unop( Iop_64to32,
10900 assign( significand64,
10903 assign( exp_min_normal,mkU64( 398 - 383 ) );
10904 assign( min_subnormalD64,
10909 assign( ccIR_subnormal,
10915 assign( ccIR_zero,
10930 assign( frAI64_lo, unop( Iop_ReinterpD64asI64,
10933 assign( gfield_mask, mkU32( DFP_G_FIELD_EXTND_MASK ) );
10936 assign( exponent, unop( Iop_64to32,
10941 assign( exp_min_normal, mkU64( 6176 - 6143 ) );
10942 assign( significand128,
10947 assign( min_subnormalD128,
10952 assign( ccIR_subnormal,
10962 assign( ccIR_zero,
10982 assign( gfield, binop( Iop_And32,
10997 assign( infinity_true,
11005 assign( SNaN_true,
11013 assign( QNaN_true,
11024 assign( zero_true,
11040 assign( subnormal_true,
11061 assign( normal_true,
11086 assign( dcm0, binop( Iop_Shl32,
11089 assign( dcm1, binop( Iop_Shl32,
11094 assign( dcm2, binop( Iop_Shl32,
11099 assign( dcm3, binop( Iop_Shl32,
11104 assign( dcm4, binop( Iop_Shl32,
11109 assign( dcm5, binop( Iop_And32, mkexpr( SNaN_true), mkU32( 1 ) ) );
11113 assign( extreme_true, binop( Iop_Or32,
11127 assign( lmd_zero_true, unop( Iop_1Sto32,
11142 assign( dcm0, binop( Iop_Shl32,
11151 assign( dcm1, binop( Iop_Shl32,
11159 assign( dcm2, binop( Iop_Shl32,
11169 assign( dcm3, binop( Iop_Shl32,
11183 assign( dcm4, binop( Iop_Shl32,
11197 assign( dcm5, binop( Iop_And32,
11207 assign( DCM_calc,
11221 assign( sign,
11242 assign( field, binop( Iop_Or32,
11276 assign( frB, getDReg( frB_addr ) );
11277 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
11283 assign( bcd64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
11284 assign( bcd_u, unop( Iop_64HIto32, mkexpr( bcd64 ) ) );
11285 assign( bcd_l, unop( Iop_64to32, mkexpr( bcd64 ) ) );
11294 assign( result,
11311 assign( sign,
11323 assign( tmp32,
11330 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
11339 assign( result,
11372 assign( dbcd64, unop( Iop_BCDtoDPB, mkexpr(frBI64 ) ) );
11373 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( dbcd64 ) ) );
11374 assign( dbcd_l, unop( Iop_64to32, mkexpr( dbcd64 ) ) );
11376 assign( lmd,
11383 assign( invalid_mask,
11386 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11388 assign( without_lmd,
11396 assign( left_exp,
11403 assign( g0_4,
11408 assign( tmp64,
11428 assign( tmp, unop( Iop_BCDtoDPB,
11444 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( tmp ) ) );
11445 assign( dbcd_l, unop( Iop_64to32, mkexpr( tmp ) ) );
11448 assign( sign,
11453 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
11454 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
11455 assign( sign_bit,
11462 assign( invalid_mask,
11473 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11476 assign( tmp64,
11491 assign( resultD64,
11535 assign( frB_hi, getDReg( frB_addr ) );
11536 assign( frB_lo, getDReg( frB_addr + 1 ) );
11537 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
11538 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
11564 assign( result_hi,
11581 assign( result_lo,
11599 assign( sign,
11612 assign( tmp32,
11619 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
11625 assign( result_hi,
11634 assign( result_lo,
11681 assign( sign_bit, mkU32( 0 ) ); // set to zero for unsigned string
11683 assign( bcd_top_8,
11692 assign( bcd_mid_60,
11714 assign( bcd_low_60, mkexpr( frBI64_lo ) );
11716 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr( bcd_top_8 ) ) );
11717 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
11719 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr( bcd_mid_60 ) ) );
11720 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
11721 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
11723 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
11724 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
11725 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
11731 assign( lmd, mkU32( 0 ) );
11733 assign( invalid_mask,
11756 assign( sign,
11760 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
11761 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
11762 assign( sign_bit,
11767 assign( bcd_top_8,
11775 assign( bcd_mid_60, mkexpr( frBI64_hi ) );
11778 assign( bcd_low_60,
11793 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr(bcd_top_8 ) ) );
11794 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
11796 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr(bcd_mid_60 ) ) );
11797 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
11798 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
11800 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
11801 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
11802 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
11807 assign( lmd, mkU32( 0 ) );
11812 assign( zero, mkU32( 0 ) );
11813 assign( inval_bcd_digit_mask,
11829 assign( invalid_mask,
11836 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11841 assign( dfp_significand,
11868 assign( result128,
11873 assign( tmp_hi,
11877 assign( tmp_lo,
11881 assign( result_hi,
11898 assign( result_lo,
11947 assign( frA, getDReg( frA_addr ) );
11952 assign( K, unop( Iop_32to8,
11970 assign( frB, getDReg( frB_addr ) );
11971 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
11983 assign( tmp64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
11984 assign( B_bcd_u, unop( Iop_64HIto32, mkexpr( tmp64 ) ) );
11985 assign( B_bcd_l, unop( Iop_64to32, mkexpr( tmp64 ) ) );
11987 assign( B_sig,
11993 assign( Unordered_true, Check_unordered( mkexpr( frBI64 ) ) );
12010 assign( frB_hi, getDReg( frB_addr ) );
12011 assign( frB_lo, getDReg( frB_addr + 1 ) );
12013 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
12014 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
12034 assign( B_sig,
12044 assign( Unordered_true, Check_unordered( mkexpr( frBI64_hi ) ) );
12060 assign( Eq_true_mask,
12065 assign( Lt_true_mask,
12070 assign( Gt_true_mask,
12076 assign( KisZero_true_mask,
12081 assign( KisZero_false_mask,
12087 assign( field,
12208 assign( vB, getVReg(vB_addr));
12238 /* Create and assign temps only as needed for the given instruction. */
12243 assign( xB,
12252 assign( xB,
12255 assign( xB2,
12268 assign( xB, unop( Iop_V128HIto64, getVSReg( XB ) ) );
12270 assign( xB2, unop( Iop_V128to64, getVSReg( XB ) ) );
12275 assign( xB, unop( Iop_V128HIto64, getVSReg( XB ) ) );
12281 assign( xB, handle_SNaN_to_QNaN_32(unop( Iop_64HIto32,
12287 assign( xB,
12390 assign(hiResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB)));
12391 assign(loResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB2)));
12416 assign(tempResult, unop(op, getVSReg(XB)));
12417 assign( hi64, unop(Iop_V128HIto64, mkexpr(tempResult)) );
12418 assign( lo64, unop(Iop_V128to64, mkexpr(tempResult)) );
12419 assign( res3, unop(Iop_64HIto32, mkexpr(hi64)) );
12420 assign( res2, unop(Iop_64to32, mkexpr(hi64)) );
12421 assign( res1, unop(Iop_64HIto32, mkexpr(lo64)) );
12422 assign( res0, unop(Iop_64to32, mkexpr(lo64)) );
12739 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
12740 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
12741 assign(frA2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XA ))));
12742 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XB ))));
12777 assign( hiResult,
12780 assign( loResult,
12793 assign( hiResult,
12796 assign( loResult,
12856 assign(frT, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XT ) ) ) );
12857 assign(frT2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XT ) ) ) );
12859 assign( hiResult,
12866 assign( loResult,
12892 assign( frBHi_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
12893 assign( frBLo_I64, unop(Iop_V128to64, getVSReg( XB )) );
12899 assign( flagsHi,
12904 assign( flagsLo,
12927 assign( frAHi_I64, unop(Iop_V128HIto64, getVSReg( XA )) );
12928 assign( frALo_I64, unop(Iop_V128to64, getVSReg( XA )) );
12929 assign( frBHi_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
12930 assign( frBLo_I64, unop(Iop_V128to64, getVSReg( XB )) );
12937 assign( flagsHi,
12942 assign( flagsLo,
13023 assign( res0,
13027 assign( res1,
13031 assign( res2,
13035 assign( res3,
13056 assign( res0,
13060 assign( res1,
13064 assign( res2,
13068 assign( res3,
13127 assign( res0,
13135 assign( res1,
13143 assign( res2,
13151 assign( res3,
13191 assign( flags0,
13196 assign( flags1,
13201 assign( flags2,
13206 assign( flags3,
13246 assign( flags0,
13251 assign( flags1,
13256 assign( flags2,
13261 assign( flags3,
13296 assign( vB, getVReg(vRB_addr));
13409 assign(bits0_63, unop( Iop_V128to64, mkexpr( vB ) ) );
13410 assign(bits64_127, unop( Iop_V128HIto64, mkexpr( vB ) ) );
13483 assign(ccIR, ccIR_expr);
13484 assign( condcode,
13522 assign( frA_isNaN, is_NaN( frA_I64 ) );
13523 assign( frB_isNaN, is_NaN( frB_I64 ) );
13525 assign( frA_isSNaN,
13532 assign( frB_isSNaN,
13539 assign( frA_isQNaN,
13541 assign( frB_isQNaN,
13615 assign(frA_isZero, is_Zero(frA_I64, False /*not single precision*/ ));
13616 assign(frB_isZero, is_Zero(frB_I64, False /*not single precision*/ ));
13617 assign(anyNaN, mkOR1(is_NaN(frA_I64), is_NaN(frB_I64)));
13693 assign(frB, unop(Iop_ReinterpI64asF64, mkexpr(frB_I64)));
13694 assign( intermediateResult,
13703 assign( frD,
13736 assign( is_SNAN,
13778 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
13779 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
13783 assign( sqrtHi,
13787 assign( sqrtLo,
13833 assign( sqrt3, binop( Iop_SqrtF64, rm, mkexpr( b3 ) ) );
13834 assign( sqrt2, binop( Iop_SqrtF64, rm, mkexpr( b2 ) ) );
13835 assign( sqrt1, binop( Iop_SqrtF64, rm, mkexpr( b1 ) ) );
13836 assign( sqrt0, binop( Iop_SqrtF64, rm, mkexpr( b0 ) ) );
13839 assign( res0,
13846 assign( res1,
13853 assign( res2,
13860 assign( res3,
13899 assign( a0_I64, unop( Iop_ReinterpF64asI64, mkexpr( a0 ) ) );
13900 assign( b0_I64, unop( Iop_ReinterpF64asI64, mkexpr( b0 ) ) );
13901 assign( a1_I64, unop( Iop_ReinterpF64asI64, mkexpr( a1 ) ) );
13902 assign( b1_I64, unop( Iop_ReinterpF64asI64, mkexpr( b1 ) ) );
13903 assign( a2_I64, unop( Iop_ReinterpF64asI64, mkexpr( a2 ) ) );
13904 assign( b2_I64, unop( Iop_ReinterpF64asI64, mkexpr( b2 ) ) );
13905 assign( a3_I64, unop( Iop_ReinterpF64asI64, mkexpr( a3 ) ) );
13906 assign( b3_I64, unop( Iop_ReinterpF64asI64, mkexpr( b3 ) ) );
13907 assign( res0,
13912 assign( res1,
13917 assign( res2,
13922 assign( res3,
13943 assign(frA, unop(Iop_V128HIto64, getVSReg( XA )));
13944 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
13945 assign(frA2, unop(Iop_V128to64, getVSReg( XA )));
13946 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
13959 assign(frA, unop(Iop_V128HIto64, getVSReg( XA )));
13960 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
13961 assign(frA2, unop(Iop_V128to64, getVSReg( XA )));
13962 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
13997 assign( resHi,
14014 assign( resLo,
14042 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
14043 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg(XB))));
14047 assign(abs_resultHi, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB ) ) ) );
14048 assign(abs_resultLo, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB2 ) ) ) );
14051 assign(abs_resultHi, unop( Iop_AbsF64, mkexpr( frB ) ) );
14052 assign(abs_resultLo, unop( Iop_AbsF64, mkexpr( frB2 ) ) );
14071 assign( shiftVector,
14075 assign( absVal_vector,
14083 assign( signBit_vector,
14104 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
14105 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg(XB))));
14126 assign( frBHi_I64, unop( Iop_V128HIto64, getVSReg( XB ) ) );
14128 assign( frBLo_I64, unop( Iop_V128to64, getVSReg( XB ) ) );
14184 assign(b3_I64, unop(Iop_ReinterpF64asI64, mkexpr(b3_F64)));
14185 assign(b2_I64, unop(Iop_ReinterpF64asI64, mkexpr(b2_F64)));
14186 assign(b1_I64, unop(Iop_ReinterpF64asI64, mkexpr(b1_F64)));
14187 assign(b0_I64, unop(Iop_ReinterpF64asI64, mkexpr(b0_F64)));
14237 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
14238 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
14298 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14316 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14333 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14351 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14375 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14377 assign( maddResult, unop( Iop_ReinterpF64asI64, qop( Iop_MAddF64, rm,
14395 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14397 assign( maddResult,
14419 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14421 assign( msubResult,
14443 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
14445 assign(msubResult, unop( Iop_ReinterpF64asI64,
14510 assign( frA_I64, unop( Iop_ReinterpF64asI64, mkexpr( frA ) ) );
14511 assign( frB_I64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
14523 assign( frB_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
14528 assign( flags,
14566 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
14567 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
14603 assign(frA_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vA ))));
14604 assign(frB_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vB ))));
14605 assign(frA_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vA ))));
14606 assign(frB_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vB ))));
14616 assign( hiResult,
14619 assign( loResult,
14628 assign(hi_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 2 ) ),
14630 assign( hiResult,unop( Iop_1Sto64, mkexpr( hi_GE ) ) );
14632 assign(lo_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 2 ) ),
14634 assign( loResult, unop( Iop_1Sto64, mkexpr( lo_GE ) ) );
14638 assign( hiEQlo,
14645 assign( all_elem_true,
14653 assign( all_elem_false,
14660 assign( ccPPC32,
14690 assign( vA, getVSReg( XA ) );
14691 assign( vB, getVSReg( XB ) );
14724 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
14738 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
14752 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
14785 assign( vA, getVSReg( XA ) );
14786 assign( vB, getVSReg( XB ) );
14798 assign(absVal, binop(Iop_ShrV128, binop(Iop_ShlV128, mkexpr(vB), mkU8(1)), mkU8(1)));
14810 assign( vecB_no_signbit, binop( Iop_ShrV128, binop( Iop_ShlV128,
14814 assign( vecA_signbit, binop( Iop_ShlV128, binop( Iop_ShrV128,
14818 assign( vec_result, binop( Iop_OrV128, mkexpr(vecA_signbit), mkexpr( vecB_no_signbit ) ) );
14827 assign( vec_neg_signbit, unop( Iop_NotV128, binop( Iop_ShrV128,
14839 assign( vecB_no_signbit, binop( Iop_ShrV128, binop( Iop_ShlV128,
14843 assign( vecB_signbit_comp, binop( Iop_ShlV128,
14861 assign(frA, unop(Iop_V128HIto64, mkexpr( vA )));
14862 assign(frB, unop(Iop_V128HIto64, mkexpr( vB )));
14876 assign(frB_I64, unop(Iop_V128HIto64, mkexpr( vB )));
14899 assign( frB,
14904 assign( sqrt,
14931 assign( frB,
14936 assign( sqrt,
14956 assign( frB,
14995 assign( vA, getVSReg( XA ) );
14996 assign( vB, getVSReg( XB ) );
15068 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
15137 assign( data, loadBE( Ity_I64, mkexpr( EA ) ) );
15195 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
15196 assign( vS, getVSReg( XS ) );
15216 assign(high64, unop( Iop_ReinterpI64asF64,
15218 assign(val32, unop( Iop_ReinterpF32asI32,
15254 assign( hi64, unop( Iop_V128HIto64, mkexpr( vS ) ) );
15255 assign( lo64, unop( Iop_V128to64, mkexpr( vS ) ) );
15300 assign( vA, getVSReg( XA ) );
15301 assign( vB, getVSReg( XB ) );
15311 assign( hi, binop(Iop_ShlV128, mkexpr(vA), mkU8(SHW*32)) );
15312 assign( lo, binop(Iop_ShrV128, mkexpr(vB), mkU8(128-SHW*32)) );
15313 assign ( result, binop(Iop_OrV128, mkexpr(hi), mkexpr(lo)) );
15315 assign ( result, mkexpr(vA) );
15327 assign( hi, unop(Iop_V128to64, mkexpr(vA)) );
15329 assign( hi, unop(Iop_V128HIto64, mkexpr(vA)) );
15332 assign( lo, unop(Iop_V128to64, mkexpr(vB)) );
15334 assign( lo, unop(Iop_V128HIto64, mkexpr(vB)) );
15336 assign( vT, binop(Iop_64HLtoV128, mkexpr(hi), mkexpr(lo)) );
15354 assign( a64, unop(word_op, mkexpr(vA)) );
15355 assign( ahi32, unop(Iop_64HIto32, mkexpr(a64)) );
15356 assign( alo32, unop(Iop_64to32, mkexpr(a64)) );
15358 assign( b64, unop(word_op, mkexpr(vB)) );
15359 assign( bhi32, unop(Iop_64HIto32, mkexpr(b64)) );
15360 assign( blo32, unop(Iop_64to32, mkexpr(b64)) );
15362 assign( vT, binop(Iop_64HLtoV128,
15374 assign( vC, getVSReg( XC ) );
15423 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
15424 assign( EA_align16, addr_align( mkexpr(EA), 16 ) );
15558 assign( vS, getVReg(vS_addr));
15559 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
15564 assign( eb, binop(Iop_And8, mkU8(0xF),
15567 assign( idx, binop(Iop_Shl8,
15577 assign( addr_aligned, addr_align(mkexpr(EA), 2) );
15578 assign( eb, binop(Iop_And8, mkU8(0xF),
15580 assign( idx, binop(Iop_Shl8,
15590 assign( addr_aligned, addr_align(mkexpr(EA), 4) );
15591 assign( eb, binop(Iop_And8, mkU8(0xF),
15593 assign( idx, binop(Iop_Shl8,
15647 assign( vA, getVReg(vA_addr));
15648 assign( vB, getVReg(vB_addr));
15995 assign( z3, binop(Iop_Add64, mkexpr(b3),
15999 assign( z2, binop(Iop_Add64, mkexpr(b2),
16003 assign( z1, binop(Iop_Add64, mkexpr(b1),
16007 assign( z0, binop(Iop_Add64, mkexpr(b0),
16035 assign( z3, binop(Iop_Add64, mkexpr(b3),
16039 assign( z2, binop(Iop_Add64, mkexpr(b2),
16043 assign( z1, binop(Iop_Add64, mkexpr(b1),
16047 assign( z0, binop(Iop_Add64, mkexpr(b0),
16069 assign( z3, binop(Iop_Add64, mkexpr(b3),
16071 assign( z2, binop(Iop_Add64, mkexpr(b2),
16073 assign( z1, binop(Iop_Add64, mkexpr(b1),
16075 assign( z0, binop(Iop_Add64, mkexpr(b0),
16091 assign( z2, binop(Iop_Add64, mkexpr(b2),
16093 assign( z0, binop(Iop_Add64, mkexpr(b0),
16109 assign( z0, binop(Iop_Add64, mkexpr(b0),
16140 assign( vA, getVReg(vA_addr));
16141 assign( vB, getVReg(vB_addr));
16220 assign( vA, getVReg(vA_addr));
16221 assign( vB, getVReg(vB_addr));
16232 assign( vD, binop(Iop_CmpEQ8x16, mkexpr(vA), mkexpr(vB)) );
16238 assign( vD, binop(Iop_CmpEQ16x8, mkexpr(vA), mkexpr(vB)) );
16244 assign( vD, binop(Iop_CmpEQ32x4, mkexpr(vA), mkexpr(vB)) );
16250 assign( vD, binop(Iop_CmpEQ64x2, mkexpr(vA), mkexpr(vB)) );
16256 assign( vD, binop(Iop_CmpGT8Ux16, mkexpr(vA), mkexpr(vB)) );
16262 assign( vD, binop(Iop_CmpGT16Ux8, mkexpr(vA), mkexpr(vB)) );
16268 assign( vD, binop(Iop_CmpGT32Ux4, mkexpr(vA), mkexpr(vB)) );
16274 assign( vD, binop(Iop_CmpGT64Ux2, mkexpr(vA), mkexpr(vB)) );
16280 assign( vD, binop(Iop_CmpGT8Sx16, mkexpr(vA), mkexpr(vB)) );
16286 assign( vD, binop(Iop_CmpGT16Sx8, mkexpr(vA), mkexpr(vB)) );
16292 assign( vD, binop(Iop_CmpGT32Sx4, mkexpr(vA), mkexpr(vB)) );
16298 assign( vD, binop(Iop_CmpGT64Sx2, mkexpr(vA), mkexpr(vB)) );
16351 assign( vA, getVReg(vA_addr));
16352 assign( vB, getVReg(vB_addr));
16353 assign( vC, getVReg(vC_addr));
16354 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
16367 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)));
16368 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16369 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16370 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
16371 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16372 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16373 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
16375 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
16381 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
16396 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)) );
16397 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16398 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16399 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
16400 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16401 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16402 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
16405 assign( zKonst, binop(Iop_ShlN32x4, unop(Iop_Dup32x4, mkU32(0x1)),
16408 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
16415 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
16429 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
16430 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
16431 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vC)));
16432 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
16433 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
16434 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vC)));
16435 assign(zLo, binop(Iop_Add32x4,
16438 assign(zHi, binop(Iop_Add32x4,
16455 assign( abEvn, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
16456 assign( abOdd, binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)) );
16485 assign( abEE, MK_Iop_MullOdd16Sx8( mkexpr(aEvn), mkexpr(bEvn) ));
16486 assign( abEO, binop(Iop_MullEven16Sx8, mkexpr(aEvn), mkexpr(bEvn)) );
16487 assign( abOE, MK_Iop_MullOdd16Sx8( mkexpr(aOdd), mkexpr(bOdd) ));
16488 assign( abOO, binop(Iop_MullEven16Sx8, mkexpr(aOdd), mkexpr(bOdd)) );
16501 assign( abEvn, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
16502 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
16512 assign( abEvn, MK_Iop_MullOdd16Ux8(mkexpr(vA), mkexpr(vB) ));
16513 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
16521 assign( z3, binop(Iop_Add64, mkexpr(c3),
16523 assign( z2, binop(Iop_Add64, mkexpr(c2),
16525 assign( z1, binop(Iop_Add64, mkexpr(c1),
16527 assign( z0, binop(Iop_Add64, mkexpr(c0),
16539 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
16540 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
16550 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
16551 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
16559 assign( z3, binop(Iop_Add64, mkexpr(c3),
16561 assign( z2, binop(Iop_Add64, mkexpr(c2),
16563 assign( z1, binop(Iop_Add64, mkexpr(c1),
16565 assign( z0, binop(Iop_Add64, mkexpr(c0),
16596 assign( vA, getVReg(vA_addr));
16597 assign( vB, getVReg(vB_addr));
16598 assign( vC, getVReg(vC_addr));
16648 assign( vA, getVReg(vA_addr));
16649 assign( vB, getVReg(vB_addr));
16703 assign( sh, binop(Iop_And8, mkU8(0x7),
16713 assign( sh, binop(Iop_And8, mkU8(0x78),
16741 assign( sh, binop(Iop_And8, mkU8(0x7),
16771 assign( sh, binop(Iop_And8, mkU8(0x78),
16813 assign( vA, getVReg(vA_addr));
16814 assign( vB, getVReg(vB_addr));
16815 assign( vC, getVReg(vC_addr));
16842 assign( vC_andF,
16845 assign( a_perm,
16847 assign( b_perm,
16850 assign( mask, binop(Iop_SarN8x16,
16883 assign( vrc_b, binop( Iop_AndV128, mkexpr( vC ),
16885 assign( vrc_a, binop( Iop_ShrV128,
16889 assign( a_perm, binop( Iop_Perm8x16, mkexpr( vA ), mkexpr( vrc_a ) ) );
16890 assign( b_perm, binop( Iop_Perm8x16, mkexpr( vB ), mkexpr( vrc_b ) ) );
17029 assign( vA, getVReg(vA_addr));
17030 assign( vB, getVReg(vB_addr));
17071 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17075 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17091 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17095 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17130 assign( a1, binop(Iop_ShlN16x8,
17133 assign( a2, binop(Iop_ShlN16x8,
17136 assign( a3, binop(Iop_ShrN16x8,
17139 assign( a_tmp, binop(Iop_OrV128, mkexpr(a1),
17142 assign( b1, binop(Iop_ShlN16x8,
17145 assign( b2, binop(Iop_ShlN16x8,
17148 assign( b3, binop(Iop_ShrN16x8,
17151 assign( b_tmp, binop(Iop_OrV128, mkexpr(b1),
17181 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
17185 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
17213 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
17219 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
17226 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
17233 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
17240 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
17255 assign( z0, binop(Iop_ShlN16x8,
17258 assign( z1, binop(Iop_ShrN16x8,
17261 assign( z01, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
17263 assign( z2, binop(Iop_ShrN16x8,
17268 assign( z3, binop(Iop_ShrN16x8,
17271 assign( z23, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
17288 assign( z0, binop(Iop_ShlN16x8,
17291 assign( z1, binop(Iop_ShrN16x8,
17294 assign( z01, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
17296 assign( z2, binop(Iop_ShrN16x8,
17301 assign( z3, binop(Iop_ShrN16x8,
17304 assign( z23, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
17314 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
17321 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
17347 assign( vA, getVReg(vA_addr));
17348 assign( vB, getVReg(vB_addr));
17410 assign( vA, getVReg(vRA_addr));
17420 assign( dst, binop( Iop_SHA256, mkexpr( vA ), mkU8( s_field) ) );
17468 assign(_vecA_32, unop( Iop_64to32, _vecA_low64 ) );
17469 assign(_vecB_32, unop( Iop_64to32, _vecB_low64 ) );
17472 assign(_vecA_32, unop( Iop_64HIto32, _vecA_low64 ) );
17473 assign(_vecB_32, unop( Iop_64HIto32, _vecB_low64 ) );
17476 assign(_vecA_32, unop( Iop_64to32, _vecA_high64 ) );
17477 assign(_vecB_32, unop( Iop_64to32, _vecB_high64 ) );
17480 assign(_vecA_32, unop( Iop_64HIto32, _vecA_high64 ) );
17481 assign(_vecB_32, unop( Iop_64HIto32, _vecB_high64 ) );
17485 assign(res_32, binop( Iop_Add32,
17494 assign(result, binop( Iop_OrV128,
17506 assign(tmp_result, mkexpr(result));
17509 assign(carry, unop(Iop_1Uto32, binop( Iop_CmpLT32U,
17534 assign( vA, getVReg(vRA_addr));
17535 assign( vB, getVReg(vRB_addr));
17586 assign( idx_tmp,
17592 assign( idx_LT127,
17603 assign( idx,
17610 assign( idx_LT127_ity128,
17615 assign( perm_bit,
17650 assign( vC, getVReg(vRC_addr));
17653 assign(cin, binop( Iop_And32,
17664 assign( vC, getVReg(vRC_addr));
17667 assign(cin, binop( Iop_And32,
17677 assign( vC, getVReg(vRC_addr));
17680 assign(cin, binop( Iop_And32,
17693 assign( vC, getVReg(vRC_addr));
17696 assign(cin, binop( Iop_And32,
17735 assign( vA, getVReg(vRA_addr));
17736 assign( vB, getVReg(vRB_addr));
17746 assign( dst, triop( Iop_BCDAdd, mkexpr( vA ),
17753 assign( dst, triop( Iop_BCDSub, mkexpr( vA ),
17781 assign( vA, getVReg(vA_addr));
17782 assign( vB, getVReg(vB_addr));
17783 assign( vC, getVReg(vC_addr));
17791 assign(rm, get_IR_roundingmode());
17900 assign( vA, getVReg(vA_addr));
17901 assign( vB, getVReg(vB_addr));
17912 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
17918 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
17924 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
17934 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
17944 assign( gt, unop(Iop_NotV128,
17946 assign( lt, unop(Iop_NotV128,
17953 assign( vD, binop(Iop_ShlN32x4,
17994 assign( vB, getVReg(vB_addr));
17998 assign( vScale, unop(Iop_Dup32x4, mkU32( float_to_bits(scale) )) );
18000 assign( vInvScale,
20025 // assign(n1, mkexpr(arg));
20026 // assign(n2, binop(Iop_Or32, mkexpr(n1), binop(Iop_Shr32, mkexpr(n1), mkU8(1))));
20027 // assign(n3, binop(Iop_Or32, mkexpr(n2), binop(Iop_Shr32, mkexpr(n2), mkU8(2))));
20028 // assign(n4, binop(Iop_Or32, mkexpr(n3), binop(Iop_Shr32, mkexpr(n3), mkU8(4))));
20029 // assign(n5, binop(Iop_Or32, mkexpr(n4), binop(Iop_Shr32, mkexpr(n4), mkU8(8))));
20030 // assign(n6, binop(Iop_Or32, mkexpr(n5), binop(Iop_Shr32, mkexpr(n5), mkU8(16))));
20035 // assign(n7, unop(Iop_Not32, mkexpr(n6)));
20047 // assign(n8,
20053 // assign(n9,
20059 // assign(n10,
20065 // assign(n11,
20069 // assign(n12,