Lines Matching defs:assign
601 static void assign ( IRTemp dst, IRExpr* e )
756 assign( ones8x16, unop(Iop_Dup8x16, mkU8(0x1)) );
757 assign( *vOdd, binop(Iop_MullEven8Ux16, mkexpr(ones8x16), vIn) );
758 assign( *vEvn, binop(Iop_MullEven8Ux16, mkexpr(ones8x16),
774 assign( ones8x16, unop(Iop_Dup8x16, mkU8(0x1)) );
775 assign( *vOdd, binop(Iop_MullEven8Sx16, mkexpr(ones8x16), vIn) );
776 assign( *vEvn, binop(Iop_MullEven8Sx16, mkexpr(ones8x16),
792 assign( ones16x8, unop(Iop_Dup16x8, mkU16(0x1)) );
793 assign( *vOdd, binop(Iop_MullEven16Ux8, mkexpr(ones16x8), vIn) );
794 assign( *vEvn, binop(Iop_MullEven16Ux8, mkexpr(ones16x8),
810 assign( ones16x8, unop(Iop_Dup16x8, mkU16(0x1)) );
811 assign( *vOdd, binop(Iop_MullEven16Sx8, mkexpr(ones16x8), vIn) );
812 assign( *vEvn, binop(Iop_MullEven16Sx8, mkexpr(ones16x8),
835 assign( hi64, unop(Iop_V128HIto64, t128) );
836 assign( lo64, unop(Iop_V128to64, t128) );
837 assign( *t3,
841 assign( *t2,
844 assign( *t1,
848 assign( *t0,
873 assign( hi64, unop(Iop_V128HIto64, t128) );
874 assign( lo64, unop(Iop_V128to64, t128) );
875 assign( *t3, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(hi64))) );
876 assign( *t2, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(hi64))) );
877 assign( *t1, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(lo64))) );
878 assign( *t0, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(lo64))) );
900 assign( hi64, unop(Iop_V128HIto64, t128) );
901 assign( lo64, unop(Iop_V128to64, t128) );
902 assign( *t3, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(hi64))) );
903 assign( *t2, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(hi64))) );
904 assign( *t1, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(lo64))) );
905 assign( *t0, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(lo64))) );
926 assign( hi64, unop(Iop_V128HIto64, t128) );
927 assign( lo64, unop(Iop_V128to64, t128) );
928 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
929 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
930 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
931 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
967 assign( hi32, unop(Iop_64HIto32, t64));
968 assign( lo32, unop(Iop_64to32, t64));
989 assign( hi32, unop(Iop_64HIto32, t64));
990 assign( lo32, unop(Iop_64to32, t64));
1385 assign( low, unop( Iop_D128LOtoD64, e ) );
1386 assign( high, unop( Iop_D128HItoD64, e ) );
1618 assign(mask[0], mkU32(0x55555555));
1619 assign(mask[1], mkU32(0x33333333));
1620 assign(mask[2], mkU32(0x0F0F0F0F));
1621 assign(mask[3], mkU32(0x00FF00FF));
1622 assign(mask[4], mkU32(0x0000FFFF));
1626 assign(nyu,
1646 assign( mask[0], mkU64( 0x5555555555555555ULL ) );
1647 assign( mask[1], mkU64( 0x3333333333333333ULL ) );
1648 assign( mask[2], mkU64( 0x0F0F0F0F0F0F0F0FULL ) );
1649 assign( mask[3], mkU64( 0x00FF00FF00FF00FFULL ) );
1650 assign( mask[4], mkU64( 0x0000FFFF0000FFFFULL ) );
1651 assign( mask[5], mkU64( 0x00000000FFFFFFFFULL ) );
1655 assign( nyu,
1684 assign(mask[0], mkU32(0x55555555));
1685 assign(mask[1], mkU32(0x33333333));
1686 assign(mask[2], mkU32(0x0F0F0F0F));
1687 assign(mask[3], mkU32(0x00FF00FF));
1688 assign(mask[4], mkU32(0x0000FFFF));
1692 assign(nyu1,
1706 assign(nyu2,
1716 assign(retval, unop(Iop_32Uto64, binop(Iop_Add32, mkexpr(nyu1), mkexpr(nyu2))));
2095 assign( v0, result );
2096 assign( v1, binop(Iop_ShrV128, result, mkU8(32)) );
2097 assign( v2, binop(Iop_ShrV128, result, mkU8(64)) );
2098 assign( v3, binop(Iop_ShrV128, result, mkU8(96)) );
2100 assign( rZeros, unop(Iop_1Uto8,
2110 assign( rOnes, unop(Iop_1Uto8,
2155 assign( neg, unop( op1UtoX, mkNOT1( unop( opXto1,
2378 assign( t64, binop(Iop_MullS32, argL, argR) );
2571 assign( t128, binop(Iop_MullS64, argL, argR) );
3095 assign( val, binop( Iop_Or32,
3102 assign( val, mkU32(0x0) );
3284 assign( PSPB_val, binop( Iop_32HLto64,
3289 assign( value, binop( Iop_32HLto64,
3296 assign( value, binop( Iop_And64,
3300 assign( has_perm,
3310 assign( not_valid,
3320 assign( new_src,
3545 assign( val, binop( Iop_Shr32,
3559 assign( val, binop( Iop_And32, unop( Iop_8Uto32,
3644 assign( *exp_mask, mkU32( I16_EXP_MASK ) );
3645 assign( *frac_mask, mkU32( I16_FRACTION_MASK ) );
3646 assign( *zero, mkU32( 0 ) );
3652 assign( *exp_mask, mkU32( I32_EXP_MASK ) );
3653 assign( *frac_mask, mkU32( I32_FRACTION_MASK ) );
3654 assign( *zero, mkU32( 0 ) );
3660 assign( *exp_mask, mkU64( I64_EXP_MASK ) );
3661 assign( *frac_mask, mkU64( I64_FRACTION_MASK ) );
3662 assign( *zero, mkU64( 0 ) );
3670 assign( *exp_mask, mkU64( V128_EXP_MASK ) );
3672 assign( *frac_mask, mkU64( V128_FRACTION_MASK ) );
3673 assign( *zero, mkU64( 0 ) );
3879 assign( exp_mask, mkU32( I16_EXP_MASK ) );
3880 assign( zero, mkU32( 0 ) );
3885 assign( exp_mask, mkU32( I32_EXP_MASK ) );
3886 assign( zero, mkU32( 0 ) );
3891 assign( exp_mask, mkU64( I64_EXP_MASK ) );
3892 assign( zero, mkU64( 0 ) );
3899 assign( exp_mask, mkU64( V128_EXP_MASK ) );
3900 assign( zero, mkU64( 0 ) );
3989 assign( value, mkexpr( src ) );
3990 assign( sign_bit,
3998 assign( value, mkexpr( src ) );
3999 assign( sign_bit,
4007 assign( value, mkexpr( src ) );
4008 assign( sign_bit,
4017 assign( value,
4025 assign( sign_bit,
4035 assign( NaN, is_NaN( size, value ) );
4036 assign( inf, is_Inf( size, value ) );
4037 assign( zero, is_Zero( size, value ) );
4038 assign( norm, is_Norm( size, value ) );
4039 assign( dnorm, is_Denorm( size, value ) );
4040 assign( pos, mkAND1( mkNOT1( mkexpr( sign_bit ) ), mkU1( 1 ) ) );
4041 assign( neg, mkAND1( mkexpr( sign_bit ), mkU1( 1 ) ) );
4076 assign(tmp, src);
4079 assign( is_SNAN,
4086 assign ( mask, binop( Iop_And32,
4107 assign( signbit_32, binop( Iop_Shr32,
4115 assign( resultantSignbit,
4124 assign( negatedResult,
4152 assign( signbit_32, binop( Iop_Shr32,
4159 assign( resultantSignbit,
4168 assign( negatedResult,
4200 assign( sign_A, binop( Iop_Shr64,
4203 assign( sign_B, binop( Iop_Shr64,
4206 assign( exp_A, binop( Iop_And64,
4211 assign( exp_B, binop( Iop_And64,
4216 assign( frac_A_hi, binop( Iop_And64,
4219 assign( frac_B_hi, binop( Iop_And64,
4222 assign( frac_A_lo, unop( Iop_V128to64, mkexpr( src_A ) ) );
4223 assign( frac_B_lo, unop( Iop_V128to64, mkexpr( src_B ) ) );
4331 assign( valid_num[0], mkU1( 1 ) ); // Assume true to start
4336 assign( digit[i], binop( Iop_And64,
4343 assign( valid_num[i+1],
4406 assign( valid_num[0], mkU1( 1) ); // Assume true to start
4419 assign( digit[i], binop( Iop_And64,
4426 assign( valid_num[i+1],
4474 assign( valid,
4490 assign( tsrc, src);
4580 assign( bcd_result0,
4590 assign( bcd_result1,
4600 assign( bcd_result2,
4610 assign( bcd_result3,
4624 assign( bcd_result,
4653 assign( result_low,
4662 assign( result_hi,
4672 assign( result,
4695 assign( result_low,
4702 assign( result_hi,
4709 assign( result,
4721 assign( result,
4744 assign( result,
4782 assign( vA_word0, unop( Iop_64to32, unop( Iop_V128to64, vA ) ) );
4783 assign( vA_word1, unop( Iop_64HIto32, unop( Iop_V128to64, vA ) ) );
4784 assign( vA_word2, unop( Iop_64to32, unop( Iop_V128HIto64, vA ) ) );
4785 assign( vA_word3, unop( Iop_64HIto32, unop( Iop_V128HIto64, vA ) ) );
4787 assign( vB_word0, unop( Iop_64to32, unop( Iop_V128to64, vB ) ) );
4788 assign( vB_word1, unop( Iop_64HIto32, unop( Iop_V128to64, vB ) ) );
4789 assign( vB_word2, unop( Iop_64to32, unop( Iop_V128HIto64, vB ) ) );
4790 assign( vB_word3, unop( Iop_64HIto32, unop( Iop_V128HIto64, vB ) ) );
4792 assign( eq_word3, binop( Iop_CmpEQ32, mkexpr( vA_word3 ),
4794 assign( eq_word2, binop( Iop_CmpEQ32, mkexpr( vA_word2 ),
4796 assign( eq_word1, binop( Iop_CmpEQ32, mkexpr( vA_word1 ),
4807 assign( result, mkOR1(
4887 assign( rA, getIReg( rA_addr ) );
4888 assign( rB, getIReg( rB_addr ) );
4889 assign( rC, getIReg( rC_addr ) );
4895 assign( result, binop( Iop_MullS64, mkexpr( rA ), mkexpr( rB ) ) );
4896 assign( tmpLo, unop( Iop_128to64, mkexpr( result ) ) );
4897 assign( tmpHi, unop( Iop_128HIto64, mkexpr( result ) ) );
4905 assign( resultLo, binop( Iop_Add64, mkexpr( tmpLo ), mkexpr( rC ) ) );
4906 assign( tmp2Hi, binop( Iop_Add64,
4919 assign( rD, binop( Iop_Add64,
4927 assign( result, binop( Iop_MullU64, mkexpr( rA ), mkexpr( rB ) ) );
4928 assign( tmpLo, unop( Iop_128to64, mkexpr( result ) ) );
4929 assign( tmpHi, unop( Iop_128HIto64, mkexpr( result ) ) );
4935 assign( resultLo, binop( Iop_Add64, mkexpr( tmpLo ), mkexpr( rC ) ) );
4942 assign( rD, binop( Iop_Add64,
4950 assign( result, binop( Iop_MullS64, mkexpr( rA ), mkexpr( rB ) ) );
4951 assign( tmpLo, unop( Iop_128to64, mkexpr( result ) ) );
4952 assign( tmpHi, unop( Iop_128HIto64, mkexpr( result ) ) );
4954 assign( rD, binop( Iop_Add64, mkexpr( tmpLo ), mkexpr( rC ) ) );
4987 assign( rA, getIReg(rA_addr) );
4988 assign( rB, getIReg(rB_addr) ); // XO-Form: rD, rA, rB
4994 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5003 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5017 assign( rD, mkSzExtendS16(ty, uimm16) );
5020 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5029 assign( rD, mkSzExtendS32(ty, uimm16 << 16) );
5032 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5040 assign( rD, unop(Iop_128to64,
5044 assign( rD, unop(Iop_64to32,
5052 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
5069 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5081 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5098 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5099 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5114 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5143 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5145 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
5169 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5170 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5196 assign( rD, mk64lo32Uto64( binop(Iop_DivS64, dividend,
5203 assign( rD, binop(Iop_DivS32, mkexpr(rA), mkexpr(rB)) );
5227 assign( rD, mk64lo32Uto64( binop(Iop_DivU64, dividend,
5234 assign( rD, binop(Iop_DivU32, mkexpr(rA), mkexpr(rB)) );
5253 assign( rD, binop(Iop_Sar64,
5259 assign( rD, unop(Iop_64HIto32,
5275 assign( rD, binop(Iop_Sar64,
5281 assign( rD, unop(Iop_64HIto32,
5296 assign( rD, binop(Iop_MullS32, a, b) );
5303 assign( rD, unop(Iop_64to32,
5322 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5336 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
5349 assign( rD, binop( mkSzOp(ty, Iop_Sub8),
5366 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5367 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5393 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5395 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5420 assign( old_xer_ca, mkWidenFrom32(ty, getXER_CA_32(), False) );
5421 assign( rD, binop( mkSzOp(ty, Iop_Add8),
5443 assign( rD, unop(Iop_128HIto64,
5456 assign( rD, unop(Iop_128HIto64,
5465 assign( rD, binop(Iop_Mul64, mkexpr(rA), mkexpr(rB)) );
5482 assign( rD, binop(Iop_DivS64, mkexpr(rA), mkexpr(rB)) );
5497 assign( rD, binop(Iop_DivU64, mkexpr(rA), mkexpr(rB)) );
5522 assign( res, binop( Iop_DivU32E, dividend, divisor ) );
5523 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
5527 assign( res, binop( Iop_DivU32E, dividend, divisor ) );
5528 assign( rD, mkexpr( res) );
5558 assign( res, binop( Iop_DivS32E, dividend, divisor ) );
5559 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
5563 assign( res, binop( Iop_DivS32E, dividend, divisor ) );
5564 assign( rD, mkexpr( res) );
5588 assign( rD, binop(Iop_DivS64E, mkexpr(rA), mkexpr(rB)) );
5602 assign( rD, binop(Iop_DivU64E, mkexpr(rA), mkexpr(rB)) );
5656 assign( rA, getIReg( rA_addr ) );
5657 assign( rB, getIReg( rB_addr ) );
5659 assign( quotient,
5662 assign( quotientTimesDivisor,
5667 assign( remainder,
5675 assign( rB_0, unop( Iop_1Sto64,
5680 assign (rD, binop( Iop_And64,
5702 assign( rA, unop( Iop_64to32, getIReg( rA_addr ) ) );
5703 assign( rB, unop( Iop_64to32, getIReg( rB_addr ) ) );
5706 assign( rA, getIReg( rA_addr ) );
5707 assign( rB, getIReg( rB_addr ) );
5710 assign( quotient,
5713 assign( quotientTimesDivisor,
5719 assign( remainder,
5727 assign( rB_0, unop( Iop_1Sto32,
5732 assign (rD, binop( Iop_32HLto64,
5756 assign( rS, getIReg( rS_address ) );
5757 assign( result, unop( Iop_Ctz32,
5759 assign( rA, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( result ) ) );
5787 assign( rS, getIReg( rS_address ) );
5788 assign( rA, unop( Iop_Ctz64, mkexpr( rS ) ) );
5818 assign( rA, getIReg( rA_addr ) );
5819 assign( rB, getIReg( rB_addr ) );
5821 assign( rA2_63, unop ( Iop_1Sto64,
5825 assign( rB_0, binop( Iop_CmpEQ64,
5829 assign( rB_1, binop( Iop_CmpEQ64,
5833 assign( rA_1, binop( Iop_CmpEQ64,
5842 assign( resultis0,
5846 assign( resultisF,
5859 assign( quotient,
5862 assign( quotientTimesDivisor,
5867 assign( remainder,
5872 assign( tmp, binop( Iop_And64,
5877 assign( rD, binop( Iop_Or64,
5906 assign( rA, unop(Iop_64to32, getIReg(rA_addr) ) );
5907 assign( rB, unop(Iop_64to32, getIReg(rB_addr) ) );
5910 assign( rA, getIReg(rA_addr) );
5911 assign( rB, getIReg(rB_addr) );
5914 assign( rA2_32, unop( Iop_1Sto32,
5922 assign( rB_0, binop( Iop_CmpEQ32,
5926 assign( rB_1, binop( Iop_CmpEQ32,
5930 assign( rA_1, binop( Iop_CmpEQ32,
5939 assign( resultis0,
5949 assign( resultisF,
5962 assign( quotient,
5965 assign( quotientTimesDivisor,
5971 assign( remainder,
5976 assign( tmp, binop( Iop_32HLto64,
5983 assign( rD, binop( Iop_Or64,
6024 assign( rA, getIReg(rA_addr) );
6025 assign( rB, getIReg(rB_addr) );
6093 assign( tmp[0], mkU32( 0 ) );
6097 assign( tmp[i+1], binop( Iop_Or32,
6284 assign
6289 assign( cr0, binop( Iop_And32,
6294 assign( cr1, binop( Iop_And32,
6299 assign( result, binop( Iop_Or64,
6352 assign( rS, getIReg(rS_addr) );
6353 assign( rB, getIReg(rB_addr) );
6358 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
6366 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
6374 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
6380 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
6386 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
6392 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
6411 assign( temp, unop( Iop_32Sto64,
6413 assign( rA, binop( Iop_Shl64, mkexpr( temp ), mkU8( sh ) ) );
6433 assign(rA, binop( mkSzOp(ty, Iop_And8),
6440 assign(rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
6459 assign(rA, mkWidenFrom32(ty,
6465 // TODO: alternatively: assign(rA, verbose_Clz32(rS));
6472 assign( rA, unop( mkSzOp(ty, Iop_Not8),
6485 assign( rA, unop(Iop_8Sto64, unop(Iop_64to8, mkexpr(rS))) );
6487 assign( rA, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rS))) );
6498 assign( rA, unop(Iop_16Sto64,
6501 assign( rA, unop(Iop_16Sto32,
6508 assign( rA, unop( mkSzOp(ty, Iop_Not8),
6516 assign( rA, unop( mkSzOp(ty, Iop_Not8),
6524 assign( rA, mkexpr(rS) );
6528 assign( rA, binop( mkSzOp(ty, Iop_Or8),
6536 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
6543 assign( rA, binop( mkSzOp(ty, Iop_Xor8),
6555 assign(rA, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(rS))));
6567 assign(rA, IRExpr_ITE( irx,
6570 // TODO: alternatively: assign(rA, verbose_Clz64(rS));
6577 assign( rA, unop( Iop_V128to64,
6583 assign( rA, unop( Iop_V128to32,
6594 assign( frB, getFReg(rB_addr)); // always F64
6596 assign( rA, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
6598 assign( rA, unop( Iop_64to32, unop( Iop_ReinterpF64asI64, mkexpr(frB))) );
6609 assign( frA, unop( Iop_ReinterpI64asF64, mkexpr(rB)) );
6611 assign( frA, unop( Iop_ReinterpI64asF64, unop( Iop_32Uto64, mkexpr(rB))) );
6630 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
6631 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
6649 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
6650 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
6682 assign( idx_tmp,
6684 assign( idx_LT64,
6686 assign( idx,
6696 assign( idx_LT64_ity64,
6698 assign( perm_bit,
6779 assign( rS, getIReg(rS_addr) );
6784 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
6785 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
6786 assign( iTot2, binop(Iop_Add32,
6789 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
6790 assign( iTot3, binop(Iop_Add32,
6793 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
6794 assign( iTot4, binop(Iop_Add32,
6798 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
6799 assign( iTot5, binop(Iop_Add32,
6802 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
6803 assign( iTot6, binop(Iop_Add32,
6806 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
6807 assign( iTot7, binop(Iop_Add32,
6810 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)) );
6811 assign( iTot8, binop(Iop_Add32,
6814 assign( rA, unop(Iop_32Uto64,
6817 assign( rA, mkexpr(iTot4) );
6821 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
6822 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
6823 assign( iTot2, binop(Iop_Add32,
6826 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
6827 assign( iTot3, binop(Iop_Add32,
6830 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
6831 assign( iTot4, binop(Iop_Add32,
6834 assign( iLo, unop(Iop_1Uto32, unop(Iop_32to1, mkexpr(iTot4) )) );
6837 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
6838 assign( iTot5, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))) );
6839 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
6840 assign( iTot6, binop(Iop_Add32,
6843 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
6844 assign( iTot7, binop(Iop_Add32,
6847 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)));
6848 assign( iTot8, binop(Iop_Add32,
6851 assign( iHi, binop(Iop_And32, mkU32(1), mkexpr(iTot8)) ),
6852 assign( rA, binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo)) );
6854 assign( rA, binop(Iop_Or32, mkU32(0), mkexpr(iLo)) );
6894 assign( rS, getIReg(rS_addr) );
6895 assign( rB, getIReg(rB_addr) );
6908 assign( rot, binop(Iop_Or64, r,
6910 assign( rA,
6919 assign( rA,
6942 assign( rTmp, r );
6944 assign( rot, binop(Iop_Or64, mkexpr(rTmp),
6946 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
6954 assign( rA, binop(Iop_Shl32, mkexpr(rS), mkU8(sh_imm)) );
6961 assign( rA, binop(Iop_Shr32, mkexpr(rS), mkU8(MaskBeg)) );
6969 assign( rA, binop(Iop_And32,
6991 assign(rot, binop(Iop_Or64, r, binop(Iop_Shl64, r, mkU8(32))));
6992 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
6997 assign( rA, binop(Iop_And32,
7023 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
7029 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
7039 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
7046 assign(rA, r & m);
7056 assign( rA, binop(Iop_Shr64, mkexpr(rS), mkU8(msk_imm)) );
7062 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
7073 assign( rA, binop(Iop_Shl64, mkexpr(rS), mkU8(sh_imm)) );
7079 assign( rA, binop(Iop_And64, r, mkU64(mask64)) );
7089 assign( rA_orig, getIReg(rA_addr) );
7090 assign( rA, binop(Iop_Or64,
7139 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
7144 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
7149 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
7152 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
7383 assign(high, load(ty, mkexpr( EA ) ) );
7384 assign(low, load(ty, binop( Iop_Add64,
7388 assign(low, load(ty, mkexpr( EA ) ) );
7389 assign(high, load(ty, binop( Iop_Add64,
7394 assign(high, load(ty, binop( Iop_Add32,
7397 assign(low, load(ty, binop( Iop_Add32,
7436 assign( rB, getIReg(rB_addr) );
7437 assign( rS, getIReg(rS_addr) );
7441 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
7447 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
7603 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
7606 assign( EA_lo, ea_rAor0_simm( rA_addr, simm16+8 ) );
7609 assign
7612 assign( EA_lo, ea_rAor0_simm( rA_addr, simm16 ) );
7616 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16+4 ) );
7619 assign( EA_lo, ea_rAor0_simm( rA_addr, simm16+12 ) );
7660 assign( EA, ea_rAor0_simm( rA_addr, simm16 ) );
7815 assign( t_EA, ea_rAor0(rA_addr) );
7826 assign( t_nbytes, mkU32(NumBytes==0 ? 32 : NumBytes) );
7843 assign( t_EA, ea_rAor0_idxd(rA_addr,rB_addr) );
7844 assign( t_nbytes, unop( Iop_8Uto32, getXER_BC() ) );
7851 assign( t_EA, ea_rAor0(rA_addr) );
7861 assign( t_nbytes, mkU32(NumBytes==0 ? 32 : NumBytes) );
7870 assign( t_EA, ea_rAor0_idxd(rA_addr,rB_addr) );
7871 assign( t_nbytes, unop( Iop_8Uto32, getXER_BC() ) );
7900 assign( ok, mkU32(0xFFFFFFFF) );
7903 assign( ok, unop( Iop_1Sto32,
7908 assign( ok, unop( Iop_1Sto32,
7930 assign( res, mkU32(1) );
7935 assign( cr_bi, getCRbit_anywhere( BI, &where ) );
7939 assign( res, mkexpr(cr_bi) );
7944 assign( res, binop(Iop_Xor32, mkexpr(cr_bi),
8013 assign(t_tgt, mode64 ? mkU64(tgt) : mkU32(tgt) );
8043 assign( ctr_ok, branch_ctr_ok( BO ) );
8044 assign( cond_ok, branch_cond_ok( BO, BI ) );
8045 assign( do_branch,
8083 assign( cond_ok, branch_cond_ok( BO, BI ) );
8087 assign( lr_old, addr_align( getGST( PPC_GST_CTR ), 4 ));
8122 assign( ctr_ok, branch_ctr_ok( BO ) );
8123 assign( cond_ok, branch_cond_ok( BO, BI ) );
8124 assign( do_branch,
8127 assign( lr_old, addr_align( getGST( PPC_GST_LR ), 4 ));
8248 assign( crbA, getCRbit(crbA_addr) );
8252 assign( crbB, getCRbit(crbB_addr) );
8257 assign( crbD, binop(Iop_And32, mkexpr(crbA), mkexpr(crbB)) );
8261 assign( crbD, binop(Iop_And32,
8267 assign( crbD, unop(Iop_Not32,
8272 assign( crbD, unop(Iop_Not32,
8277 assign( crbD, unop(Iop_Not32,
8282 assign( crbD, binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB)) );
8286 assign( crbD, binop(Iop_Or32,
8292 assign( crbD, binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB)) );
8365 assign( argL, argL0 );
8366 assign( argR, argR0 );
8566 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
8674 assign( rS, mkNarrowTo32(ty, getIReg(rS_addr)) );
8705 assign( rS, mkNarrowTo8(ty, getIReg(rS_addr)) );
8739 assign( rS, mkNarrowTo16(ty, getIReg(rS_addr)) );
8832 assign( rS, getIReg(rS_addr) );
8907 assign( rS_hi, getIReg(rS_addr) );
8908 assign( rS_lo, getIReg(rS_addr+1) );
8979 assign( rS, getIReg(rS_addr) );
8980 assign( rB, getIReg(rB_addr) );
8981 assign( rS_lo32, mkNarrowTo32(ty, mkexpr(rS)) );
8982 assign( rB_lo32, mkNarrowTo32(ty, mkexpr(rB)) );
9006 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */False) );
9019 assign( sh_amt, binop(Iop_And32, mkU32(0x3F),
9021 assign( outofrange,
9029 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */True) );
9044 assign( rA, binop(Iop_Sar64,
9049 assign( rA, binop(Iop_Sar32, mkexpr(rS_lo32),
9082 assign( rA, mkWidenFrom32(ty, e_tmp, /* Signed */False) );
9096 assign( rA,
9117 assign( sh_amt, binop(Iop_And64, mkU64(0x7F), mkexpr(rB)) );
9118 assign( outofrange,
9120 assign( rA,
9139 assign( rA, binop(Iop_Sar64, getIReg(rS_addr), mkU8(sh_imm)) );
9157 assign( rA,
9245 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
9251 assign( w1, unop(Iop_16Uto32, load(Ity_I16, mkexpr(EA))) );
9252 assign( w2, gen_byterev16(w1) );
9259 assign( w1, load(Ity_I32, mkexpr(EA)) );
9260 assign( w2, gen_byterev32(w1) );
9271 assign( w1, load( Ity_I32, mkexpr( EA ) ) );
9272 assign( w2, gen_byterev32( w1 ) );
9275 assign( w3, load( Ity_I32, nextAddr ) );
9276 assign( w4, gen_byterev32( w3 ) );
9286 assign( w1, mkNarrowTo32(ty, getIReg(rS_addr)) );
9292 assign( w1, mkNarrowTo32(ty, getIReg(rS_addr)) );
9301 assign( rS, getIReg( rS_addr ) );
9303 assign(lo, unop(Iop_64HIto32, mkexpr(rS)));
9304 assign(hi, unop(Iop_64to32, mkexpr(rS)));
9346 assign( rS, getIReg(rS_addr) );
9635 assign( vS, getVSReg( XS ) );
9657 assign( vS, getVSReg( XS ) );
9680 assign( rA, getIReg(rA_addr) );
9707 assign( rA, unop( Iop_64to32, getIReg( rA_addr ) ) );
9709 assign( rA, getIReg(rA_addr) );
9731 assign( rA, unop( Iop_64to32, getIReg( rA_addr ) ) );
9733 assign( rA, getIReg(rA_addr) );
9843 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
9847 assign( addr, binop( Iop_And64,
9857 assign( addr, binop( Iop_And32,
9876 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
9879 assign( addr, binop( mkSzOp(ty, Iop_And8),
9947 assign( rm_PPC32, getGST_masked( PPC_GST_FPSCR, MASK_FPSCR_RN ) );
9975 assign( rm_PPC32, getGST_masked_upper( PPC_GST_FPSCR, MASK_FPSCR_DRN ) );
10009 assign( frac_mask, unop( Iop_Not32,
10013 assign( exp_zero,
10022 assign( frac_not_zero,
10096 assign( rA, getIReg(rA_addr) );
10097 assign( rB, getIReg(rB_addr) );
10106 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
10115 assign( EA, ea_rA_simm(rA_addr, simm16) );
10123 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
10131 assign( EA, ea_rA_simm(rA_addr, simm16) );
10145 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
10154 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
10162 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
10170 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
10177 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
10178 assign( iLo, load(Ity_I32, mkexpr(EA)) );
10179 assign( iHi, binop(Iop_Sub32,
10190 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
10191 assign( iLo, load(Ity_I32, mkexpr(EA)) );
10192 assign( dw, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( iLo ) ) );
10233 assign( frS, getFReg(frS_addr) );
10234 assign( rA, getIReg(rA_addr) );
10235 assign( rB, getIReg(rB_addr) );
10246 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
10257 assign( EA, ea_rA_simm(rA_addr, simm16) );
10265 assign( EA, ea_rAor0_simm(rA_addr, simm16) );
10273 assign( EA, ea_rA_simm(rA_addr, simm16) );
10286 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
10296 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
10304 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
10312 assign( EA, ea_rA_idxd(rA_addr, rB_addr) );
10320 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
10371 assign( frA, getFReg(frA_addr));
10372 assign( frB, getFReg(frB_addr));
10373 assign( frC, getFReg(frC_addr));
10383 assign( frD, triop( Iop_DivF64r32,
10392 assign( frD, triop( Iop_SubF64r32,
10401 assign( frD, triop( Iop_AddF64r32,
10413 assign( frD, binop( Iop_SqrtF64, rm, mkexpr(frB) ));
10424 assign( frD, triop( Iop_DivF64r32,
10435 assign( frD, triop( Iop_MulF64r32,
10446 assign( frD, unop(Iop_RSqrtEst5GoodF64, mkexpr(frB)) );
10462 assign( frD, triop(Iop_DivF64, rm, mkexpr(frA), mkexpr(frB)) );
10470 assign( frD, triop(Iop_SubF64, rm, mkexpr(frA), mkexpr(frB)) );
10478 assign( frD, triop(Iop_AddF64, rm, mkexpr(frA), mkexpr(frB)) );
10487 assign( frD, binop(Iop_SqrtF64, rm, mkexpr(frB)) );
10500 assign( cc, binop(Iop_CmpF64, mkexpr(frA),
10502 assign( cc_b0, binop(Iop_And32, mkexpr(cc), mkU32(1)) );
10506 assign( frD,
10527 assign( frD, triop( Iop_DivF64,
10538 assign( frD, triop(Iop_MulF64, rm, mkexpr(frA), mkexpr(frC)) );
10547 assign( frD, unop(Iop_RSqrtEst5GoodF64, mkexpr(frB)) );
10616 assign( rmt, get_IR_roundingmode() );
10619 assign( frA, getFReg(frA_addr));
10620 assign( frB, getFReg(frB_addr));
10621 assign( frC, getFReg(frC_addr));
10637 assign( frD, qop( Iop_MSubF64r32, rm,
10644 assign( frD, qop( Iop_MAddF64r32, rm,
10654 assign( tmp, qop( Iop_MSubF64r32, rm,
10659 assign( tmp, qop( Iop_MAddF64r32, rm,
10663 assign( nan_mask, Check_NaN( mkexpr( tmp ),
10665 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
10667 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
10681 assign( frD, qop( Iop_MSubF64, rm,
10688 assign( frD, qop( Iop_MAddF64, rm,
10698 assign( tmp, qop( Iop_MSubF64, rm,
10703 assign( tmp, qop( Iop_MAddF64, rm,
10707 assign( nan_mask, Check_NaN( mkexpr( tmp ),
10709 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
10711 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
10769 assign( frB_exp_shR, fp_exp_part( Ity_I32, frB_Int ) );
10771 assign( frB_exp_shR, fp_exp_part( Ity_I64, frB_Int ) );
10773 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
10782 assign( frbInf_tmp, is_Inf( Ity_I32, frB_Int ) );
10783 assign( frbZero_tmp, is_Zero( Ity_I32, frB_Int ) );
10787 assign( frbInf_tmp, is_Inf( Ity_I64, frB_Int ) );
10788 assign( frbZero_tmp, is_Zero( Ity_I64, frB_Int ) );
10818 assign( frac_part, binop( Iop_And32, mkexpr(frB_Int), mkU32(0x007fffff)) );
10826 assign( frac_part, FP_FRAC_PART(frB_Int) );
10848 assign (*fg_flag_tmp, fg_flag);
10849 assign (*fe_flag_tmp, fe_flag);
10905 assign( frA_exp_shR, fp_exp_part( Ity_I32, frA_int ) );
10906 assign( frB_exp_shR, fp_exp_part( Ity_I32, frB_int ) );
10908 assign( frA_exp_shR, fp_exp_part( Ity_I64, frA_int ) );
10909 assign( frB_exp_shR, fp_exp_part( Ity_I64, frB_int ) );
10913 assign(e_a, binop( Iop_Sub32, mkexpr(frA_exp_shR), mkU32( bias ) ));
10914 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
10930 assign(fraInf_tmp, is_Inf( Ity_I32, frA_int ) );
10931 assign( frbInf_tmp, is_Inf( Ity_I32, frB_int ) );
10932 assign( frbZero_tmp, is_Zero( Ity_I32, frB_int ) );
10935 assign(fraInf_tmp, is_Inf( Ity_I64, frA_int ) );
10936 assign( frbInf_tmp, is_Inf( Ity_I64, frB_int ) );
10937 assign( frbZero_tmp, is_Zero( Ity_I64, frB_int ) );
10967 assign( fraNotZero_tmp, unop( Iop_Not1, is_Zero( Ity_I32, frA_int ) ) );
10969 assign( fraNotZero_tmp, unop( Iop_Not1, is_Zero( Ity_I64, frA_int ) ) );
11025 assign( frac_part, FP_FRAC_PART(frB_int) );
11061 assign(*fe_flag_tmp, fe_flag);
11062 assign(*fg_flag_tmp, fg_flag);
11096 assign( frB_I64, unop( Iop_ReinterpF64asI64, getFReg( frB_addr ) ) );
11109 assign( frA_I64, unop( Iop_ReinterpF64asI64, getFReg( frA_addr ) ) );
11130 assign( flags,
11172 assign( frA, getFReg(frA_addr));
11173 assign( frB, getFReg(frB_addr));
11175 assign( ccIR, binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)) );
11189 assign(
11278 assign( frB, getFReg(frB_addr));
11287 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
11288 assign( frD, binop( Iop_RoundF64toF32, rm, binop( Iop_I64StoF64, rm,
11294 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
11295 assign( frD, unop( Iop_F32toF64, binop( Iop_I64UtoF32, rm, mkexpr( r_tmp64 ) ) ) );
11304 assign( frD, binop( Iop_RoundF64toF32, rm, mkexpr(frB) ));
11309 assign( r_tmp32,
11311 assign( frD, unop( Iop_ReinterpI64asF64,
11319 assign( r_tmp32,
11321 assign( frD, unop( Iop_ReinterpI64asF64,
11330 assign( r_tmp32,
11334 assign( frD, unop( Iop_ReinterpI64asF64,
11343 assign( r_tmp64,
11345 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
11352 assign( r_tmp64,
11354 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
11363 assign( r_tmp64,
11365 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
11372 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
11373 assign( frD,
11379 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
11380 assign( frD, binop( Iop_I64UtoF64, rm, mkexpr( r_tmp64 ) ) );
11387 assign( r_tmp64,
11392 assign( r_tmp64,
11397 assign( r_tmp64,
11402 assign( r_tmp64,
11412 assign(frD, IRExpr_ITE(
11506 assign( EA_hi, ea_rAor0_idxd( rA_addr, rB_addr ) );
11527 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
11534 assign( EA, ea_rAor0_simm( rA_addr, DS<<2 ) );
11544 assign( EA, ea_rAor0_simm( rA_addr, DS<<2 ) );
11579 assign( EA_hi, ea_rAor0_simm( rA_addr, simm16 ) );
11593 assign( EA, ea_rAor0_simm( rA_addr, DS<<4 ) );
11599 assign( word[0], load( Ity_I64, mkexpr( EA ) ) );
11604 assign( word[1], load( Ity_I64, irx_addr ) );
11647 assign( EA, ea_rAor0_simm( rA_addr, DS<<2 ) );
11664 assign( EA, ea_rAor0_simm( rA_addr, DS<<2 ) );
11683 assign( EA_lo, binop(Iop_Add64, mkexpr(EA_hi), mkU64(8)) );
11685 assign( EA_lo, binop(Iop_Add32, mkexpr(EA_hi), mkU32(8)) );
11687 assign( frT_hi, getFReg(frT_hi_addr) );
11688 assign( frT_lo, getFReg(frT_lo_addr) );
11717 assign( frA, getFReg(frA_addr));
11718 assign( frB, getFReg(frB_addr));
11724 assign( frD, unop( Iop_ReinterpI64asF64,
11737 assign( frD, unop( Iop_ReinterpI64asF64,
11781 assign( frB, getFReg(frB_addr));
11791 assign( frA, getFReg(frA_addr) );
11794 assign(signA, binop(Iop_And32,
11799 assign( itmpB, unop(Iop_ReinterpF64asI64, mkexpr(frB)) );
11802 assign(hiD, binop(Iop_Or32,
11810 assign( frD, unop(Iop_ReinterpI64asF64,
11819 assign( frD, unop( Iop_NegF64, mkexpr(frB) ));
11824 assign( frD, mkexpr(frB) );
11829 assign( frD, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr(frB) )));
11834 assign( frD, unop( Iop_AbsF64, mkexpr(frB) ));
11903 assign( tmp, binop(Iop_And32,
11988 assign( frB, getFReg(frB_addr));
11989 assign( frB_int, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
12026 assign( frB, getFReg(frB_addr));
12027 assign( frB_int, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
12137 assign( frB, getFReg(frB_addr));
12138 assign( rB_64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
12218 assign( lmd_07_mask,
12220 assign( lmd_8_mask,
12222 assign( lmd_9_mask,
12224 assign( lmexp_00_mask,
12226 assign( lmexp_01_mask,
12228 assign( lmexp_10_mask,
12234 assign( lmd_07_val,
12236 assign( lmd_8_val,
12246 assign( lmd_9_val,
12298 assign( lmd_07_mask,
12302 assign( lmd_8_00_mask,
12306 assign( lmd_8_01_mask,
12310 assign( lmd_8_10_mask,
12314 assign( lmd_9_00_mask,
12318 assign( lmd_9_01_mask,
12322 assign( lmd_9_10_mask,
12330 assign( lmd_07_val, binop( Iop_And32, gfield_0_4, mkU32( 0x7 ) ) );
12331 assign( lmd_8_val, mkU32( 0x8 ) );
12332 assign( lmd_9_val, mkU32( 0x9 ) );
12334 assign( *lmd,
12360 assign( valid,
12556 assign( low_50,
12566 assign( tmplow60, unop( Iop_DPBtoBCD, mkexpr( low_50 ) ) );
12567 assign( *low_60_u, unop( Iop_64HIto32, mkexpr( tmplow60 ) ) );
12568 assign( *low_60_l, unop( Iop_64to32, mkexpr( tmplow60 ) ) );
12573 assign( mid_50,
12595 assign( tmpmid60, unop( Iop_DPBtoBCD, mkexpr( mid_50 ) ) );
12596 assign( *mid_60_u, unop( Iop_64HIto32, mkexpr( tmpmid60 ) ) );
12597 assign( *mid_60_l, unop( Iop_64to32, mkexpr( tmpmid60 ) ) );
12600 assign( top_10,
12612 assign( tmptop12, unop( Iop_DPBtoBCD, mkexpr( top_10 ) ) );
12613 assign( top_12_u, unop( Iop_64HIto32, mkexpr( tmptop12 ) ) );
12614 assign( *top_12_l, unop( Iop_64to32, mkexpr( tmptop12 ) ) );
12627 assign( cnt[start-1], init_cnt);
12628 assign( flag[start-1], init_flag);
12633 assign( cnt[i],
12649 assign( flag[i],
12675 assign( num_lmd, unop( Iop_1Uto8, binop( Iop_CmpEQ32, lmd, mkU32( 0 ) ) ) );
12676 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
12714 assign( num_lmd, unop( Iop_1Uto8, binop( Iop_CmpEQ32, lmd, mkU32( 0 ) ) ) );
12716 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
12765 assign( gfield0to5,
12818 assign( frA, getDReg( frA_addr ) );
12819 assign( frB, getDReg( frB_addr ) );
12825 assign( frS, triop( Iop_AddD64, round, mkexpr( frA ), mkexpr( frB ) ) );
12830 assign( frS, triop( Iop_SubD64, round, mkexpr( frA ), mkexpr( frB ) ) );
12835 assign( frS, triop( Iop_MulD64, round, mkexpr( frA ), mkexpr( frB ) ) );
12840 assign( frS, triop( Iop_DivD64, round, mkexpr( frA ), mkexpr( frB ) ) );
12876 assign( frA, getDReg_pair( frA_addr ) );
12877 assign( frB, getDReg_pair( frB_addr ) );
12883 assign( frS, triop( Iop_AddD128, round, mkexpr( frA ), mkexpr( frB ) ) );
12888 assign( frS, triop( Iop_SubD128, round, mkexpr( frA ), mkexpr( frB ) ) );
12893 assign( frS, triop( Iop_MulD128, round, mkexpr( frA ), mkexpr( frB ) ) );
12898 assign( frS, triop( Iop_DivD128, round, mkexpr( frA ), mkexpr( frB ) ) );
12924 assign( frA, getDReg( frA_addr ) );
12930 assign( frS, binop( Iop_ShlD64, mkexpr( frA ), mkU8( shift_val ) ) );
12935 assign( frS, binop( Iop_ShrD64, mkexpr( frA ), mkU8( shift_val ) ) );
12961 assign( frA, getDReg_pair( frA_addr ) );
12967 assign( frS, binop( Iop_ShlD128, mkexpr( frA ), mkU8( shift_val ) ) );
12972 assign( frS, binop( Iop_ShrD128, mkexpr( frA ), mkU8( shift_val ) ) );
13004 assign( frB, getDReg32( frB_addr ) );
13005 assign( frS, unop( Iop_D32toD64, mkexpr( frB ) ) );
13013 assign( frB, getDReg( frB_addr ) );
13014 assign( frS, binop( Iop_D64toD32, round, mkexpr( frB ) ) );
13025 assign( frB, getDReg( frB_addr ) );
13026 assign( tmp, binop( Iop_D64toI64S, round, mkexpr( frB ) ) );
13027 assign
13036 assign( frB, getDReg( frB_addr ) );
13037 assign( frS, binop( Iop_I64StoD64,
13069 assign( frB64, getDReg( frB_addr ) );
13070 assign( frS128, unop( Iop_D64toD128, mkexpr( frB64 ) ) );
13079 assign( frB128, getDReg_pair( frB_addr ) );
13080 assign( tmp, binop( Iop_D128toI64S, round, mkexpr( frB128 ) ) );
13081 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
13088 assign( frB128, getDReg_pair( frB_addr ) );
13089 assign( frS64, binop( Iop_D128toD64, round, mkexpr( frB128 ) ) );
13100 assign( frB64, getDReg( frB_addr ) );
13101 assign( frS128, unop( Iop_I64StoD128,
13143 assign( frB, getDReg( frB_addr ) );
13144 assign( frS, binop( Iop_RoundD64toInt,
13184 assign( frB, getDReg_pair( frB_addr ) );
13185 assign( frS, binop( Iop_RoundD128toInt,
13217 assign( frB, getDReg( frB_addr ) );
13233 assign( TE_I64,
13241 assign( TE_I64,
13247 assign( frA, binop( Iop_InsertExpD64, mkexpr( TE_I64 ),
13250 assign( frS, triop( Iop_QuantizeD64,
13259 assign( frA, getDReg( frA_addr ) );
13260 assign( frS, triop( Iop_QuantizeD64,
13271 assign( frA, getDReg( frA_addr ) );
13273 assign( tmp, unop( Iop_32to8,
13277 assign( frS, triop( Iop_SignificanceRoundD64,
13311 assign( frB, getDReg_pair( frB_addr ) );
13327 assign( TE_I64,
13335 assign( TE_I64,
13342 assign( frA,
13346 assign( frS, triop( Iop_QuantizeD128,
13354 assign( frA, getDReg_pair( frA_addr ) );
13355 assign( frS, triop( Iop_QuantizeD128,
13366 assign( frA, getDReg_pair( frA_addr ) );
13367 assign( tmp, unop( Iop_32to8,
13372 assign( frS, triop( Iop_SignificanceRoundD128,
13405 assign( frA, getDReg( frA_addr ) );
13406 assign( frB, getDReg( frB_addr ) );
13412 assign( tmp, unop( Iop_ExtractExpD64, mkexpr( frB ) ) );
13413 assign( frS, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
13418 assign( frS, binop( Iop_InsertExpD64,
13452 assign( frB, getDReg_pair( frB_addr ) );
13462 assign( tmp, unop( Iop_ExtractExpD128, mkexpr( frB ) ) );
13463 assign( frS64, unop( Iop_ReinterpI64asD64, mkexpr( tmp ) ) );
13469 assign( frA, getDReg( frA_addr ) );
13470 assign( frS, binop( Iop_InsertExpD128,
13510 assign( frA, getDReg( frA_addr ) );
13511 assign( frB, getDReg( frB_addr ) );
13513 assign( ccIR, binop( Iop_CmpD64, mkexpr( frA ), mkexpr( frB ) ) );
13520 assign( frA, getDReg_pair( frA_addr ) );
13521 assign( frB, getDReg_pair( frB_addr ) );
13522 assign( ccIR, binop( Iop_CmpD128, mkexpr( frA ), mkexpr( frB ) ) );
13539 assign( ccPPC32,
13599 assign( frA, getDReg( frA_addr ) );
13600 assign( frB, getDReg( frB_addr ) );
13601 assign( gfield_mask, mkU32( DFP_G_FIELD_LONG_MASK ) );
13602 assign(exponent_A, unop( Iop_64to32,
13605 assign(exponent_B, unop( Iop_64to32,
13612 assign( frA128, getDReg_pair( frA_addr ) );
13613 assign( frB128, getDReg_pair( frB_addr ) );
13614 assign( frA, unop( Iop_D128HItoD64, mkexpr( frA128 ) ) );
13615 assign( frB, unop( Iop_D128HItoD64, mkexpr( frB128 ) ) );
13616 assign( gfield_mask, mkU32( DFP_G_FIELD_EXTND_MASK ) );
13617 assign( exponent_A, unop( Iop_64to32,
13620 assign( exponent_B, unop( Iop_64to32,
13630 assign( gfield_A, binop( Iop_And32,
13636 assign( gfield_B, binop( Iop_And32,
13643 assign( A_NaN_true, binop(Iop_Or32,
13653 assign( B_NaN_true, binop(Iop_Or32,
13665 assign( A_inf_true,
13671 assign( B_inf_true,
13677 assign( finite_number,
13692 assign( A_equals_B,
13706 assign( cc0, binop( Iop_And32,
13715 assign( cc1, binop( Iop_And32,
13724 assign( cc2, binop( Iop_Shl32,
13730 assign( cc3, binop( Iop_And32,
13744 assign( cc, binop( Iop_Or32,
13819 assign( frA, getDReg( frA_addr ) );
13820 assign( frAI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frA ) ) );
13822 assign( abs_frA, unop( Iop_ReinterpI64asD64,
13827 assign( gfield_0_4_shift, mkU8( 31 - 5 ) ); // G-field[0:4]
13833 assign( frAI64_lo, mkU64( 0 ) );
13834 assign( gfield_mask, mkU32( DFP_G_FIELD_LONG_MASK ) );
13838 assign( exponent, unop( Iop_64to32,
13841 assign( significand64,
13844 assign( exp_min_normal,mkU64( 398 - 383 ) );
13845 assign( min_subnormalD64,
13850 assign( ccIR_subnormal,
13856 assign( ccIR_zero,
13871 assign( frAI64_lo, unop( Iop_ReinterpD64asI64,
13874 assign( gfield_mask, mkU32( DFP_G_FIELD_EXTND_MASK ) );
13877 assign( exponent, unop( Iop_64to32,
13882 assign( exp_min_normal, mkU64( 6176 - 6143 ) );
13883 assign( significand128,
13888 assign( min_subnormalD128,
13893 assign( ccIR_subnormal,
13903 assign( ccIR_zero,
13923 assign( gfield, binop( Iop_And32,
13938 assign( infinity_true,
13946 assign( SNaN_true,
13954 assign( QNaN_true,
13965 assign( zero_true,
13981 assign( subnormal_true,
14002 assign( normal_true,
14027 assign( dcm0, binop( Iop_Shl32,
14030 assign( dcm1, binop( Iop_Shl32,
14035 assign( dcm2, binop( Iop_Shl32,
14040 assign( dcm3, binop( Iop_Shl32,
14045 assign( dcm4, binop( Iop_Shl32,
14050 assign( dcm5, binop( Iop_And32, mkexpr( SNaN_true), mkU32( 1 ) ) );
14054 assign( extreme_true, binop( Iop_Or32,
14068 assign( lmd_zero_true, unop( Iop_1Sto32,
14083 assign( dcm0, binop( Iop_Shl32,
14092 assign( dcm1, binop( Iop_Shl32,
14100 assign( dcm2, binop( Iop_Shl32,
14110 assign( dcm3, binop( Iop_Shl32,
14124 assign( dcm4, binop( Iop_Shl32,
14138 assign( dcm5, binop( Iop_And32,
14148 assign( DCM_calc,
14162 assign( sign,
14183 assign( field, binop( Iop_Or32,
14218 assign( frB, getDReg( frB_addr ) );
14219 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
14225 assign( bcd64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
14226 assign( bcd_u, unop( Iop_64HIto32, mkexpr( bcd64 ) ) );
14227 assign( bcd_l, unop( Iop_64to32, mkexpr( bcd64 ) ) );
14236 assign( result,
14253 assign( sign,
14265 assign( tmp32,
14272 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
14281 assign( result,
14314 assign( dbcd64, unop( Iop_BCDtoDPB, mkexpr(frBI64 ) ) );
14315 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( dbcd64 ) ) );
14316 assign( dbcd_l, unop( Iop_64to32, mkexpr( dbcd64 ) ) );
14318 assign( lmd,
14325 assign( invalid_mask,
14328 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
14330 assign( without_lmd,
14338 assign( left_exp,
14345 assign( g0_4,
14350 assign( tmp64,
14370 assign( tmp, unop( Iop_BCDtoDPB,
14386 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( tmp ) ) );
14387 assign( dbcd_l, unop( Iop_64to32, mkexpr( tmp ) ) );
14390 assign( sign,
14395 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
14396 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
14397 assign( sign_bit,
14404 assign( invalid_mask,
14415 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
14418 assign( tmp64,
14433 assign( resultD64,
14477 assign( frB_hi, getDReg( frB_addr ) );
14478 assign( frB_lo, getDReg( frB_addr + 1 ) );
14479 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
14480 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
14506 assign( result_hi,
14523 assign( result_lo,
14541 assign( sign,
14554 assign( tmp32,
14561 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
14567 assign( result_hi,
14576 assign( result_lo,
14623 assign( sign_bit, mkU32( 0 ) ); // set to zero for unsigned string
14625 assign( bcd_top_8,
14634 assign( bcd_mid_60,
14656 assign( bcd_low_60, mkexpr( frBI64_lo ) );
14658 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr( bcd_top_8 ) ) );
14659 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
14661 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr( bcd_mid_60 ) ) );
14662 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
14663 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
14665 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
14666 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
14667 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
14673 assign( lmd, mkU32( 0 ) );
14675 assign( invalid_mask,
14698 assign( sign,
14702 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
14703 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
14704 assign( sign_bit,
14709 assign( bcd_top_8,
14717 assign( bcd_mid_60, mkexpr( frBI64_hi ) );
14720 assign( bcd_low_60,
14735 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr(bcd_top_8 ) ) );
14736 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
14738 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr(bcd_mid_60 ) ) );
14739 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
14740 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
14742 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
14743 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
14744 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
14749 assign( lmd, mkU32( 0 ) );
14754 assign( zero, mkU32( 0 ) );
14755 assign( inval_bcd_digit_mask,
14771 assign( invalid_mask,
14778 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
14783 assign( dfp_significand,
14810 assign( result128,
14815 assign( tmp_hi,
14819 assign( tmp_lo,
14823 assign( result_hi,
14840 assign( result_lo,
14895 assign( frA, getDReg( frA_addr ) );
14900 assign( K, unop( Iop_32to8,
14910 assign( K, mkU8( UIM) );
14933 assign( frB, getDReg( frB_addr ) );
14934 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
14946 assign( tmp64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
14947 assign( B_bcd_u, unop( Iop_64HIto32, mkexpr( tmp64 ) ) );
14948 assign( B_bcd_l, unop( Iop_64to32, mkexpr( tmp64 ) ) );
14950 assign( B_sig,
14957 assign( BCD_valid,
14965 assign( Unordered_true,
14990 assign( frB_hi, getDReg( frB_addr ) );
14991 assign( frB_lo, getDReg( frB_addr + 1 ) );
14993 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
14994 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
15014 assign( BCD_valid,
15024 assign( B_sig,
15037 assign( Unordered_true,
15056 assign( Eq_true_mask,
15061 assign( Lt_true_mask,
15066 assign( Gt_true_mask,
15072 assign( KisZero_true_mask,
15077 assign( KisZero_false_mask,
15083 assign( field,
15102 assign( cc, binop( Iop_Or32,
15204 assign( vB, getVReg(vB_addr));
15234 assign( vB, getVReg ( vB_addr ) );
15256 assign( count[0], mkU32( 0 ) );
15257 assign( byte_mask[0], mkU32( 0x1 ) );
15284 assign( bit_zero[i],
15298 assign( bit_zero[i],
15309 assign( count[i+1], binop( Iop_Add32,
15318 assign( byte_mask[i+1],
15333 assign( vT, binop( Iop_Mul32x4, mkexpr( vB ), mkV128( 0xFFFF ) ) );
15340 assign( vT, binop( Iop_64HLtoV128,
15361 assign( bit_in_byte[i],
15372 assign( word_parity[i],
15382 assign( vT, mkV128from32( word_parity[0], word_parity[1],
15388 assign( vT,
15404 assign( vT,
15424 assign( vT, binop( Iop_MullEven16Sx8,
15442 assign( vT, binop( Iop_MullEven16Sx8,
15457 assign( vT, binop( Iop_MullEven32Sx4,
15475 assign( vT, binop( Iop_MullEven32Sx4,
15489 assign( vT, binop( Iop_MullEven32Sx4,
15505 assign( vT, unop( Iop_Ctz8x16, mkexpr( vB ) ) );
15518 assign( vT, unop( Iop_Ctz16x8, mkexpr( vB ) ) );
15531 assign( vT, unop( Iop_Ctz32x4, mkexpr( vB ) ) );
15544 assign( vT, unop( Iop_Ctz64x2, mkexpr( vB ) ) );
15592 assign( vA, getVReg( vA_addr ) );
15593 assign( vB, getVReg( vB_addr ) );
15600 assign( field_mask, binop( Iop_64HLtoV128,
15610 assign( field_mask, binop( Iop_64HLtoV128,
15628 assign( shift[i],
15642 assign( left_bits[i],
15657 assign( right_bits[i],
15670 assign( mask[i],
15686 assign( vA_word[i], binop( Iop_AndV128,
15694 assign( tmp128[i],
15717 assign( src3, getVReg( vT_addr ) );
15718 assign( mask128, unop( Iop_NotV128,
15729 assign( vT, binop( Iop_OrV128,
15740 assign( src3, getVReg( vT_addr ) );
15741 assign( mask128, unop( Iop_NotV128,
15748 assign( vT, binop( Iop_OrV128,
15759 assign( vT, mkOr4_V128( tmp128[0], tmp128[1], tmp128[2], tmp128[3] ) );
15764 assign( vT, binop( Iop_OrV128,
15793 assign( vB, getVReg( vB_addr ) );
15794 assign( rA, getIReg( rA_addr ) );
15805 assign( rT, extract_field_from_vector( vB,
15816 assign( rT, extract_field_from_vector( vB,
15826 assign( rT, extract_field_from_vector( vB,
15836 assign( rT, extract_field_from_vector( vB, mkexpr( rA ), 0xFF ) );
15842 assign( rT, extract_field_from_vector( vB, mkexpr( rA ), 0xFFFF ) );
15848 assign( rT, extract_field_from_vector( vB, mkexpr( rA ), 0xFFFFFFFF ) );
15878 /* Create and assign temps only as needed for the given instruction. */
15883 assign( xB,
15892 assign( xB,
15895 assign( xB2,
15908 assign( xB, unop( Iop_V128HIto64, getVSReg( XB ) ) );
15910 assign( xB2, unop( Iop_V128to64, getVSReg( XB ) ) );
15915 assign( xB, unop( Iop_V128HIto64, getVSReg( XB ) ) );
15921 assign( xB, handle_SNaN_to_QNaN_32(unop( Iop_64HIto32,
15927 assign( xB,
16030 assign(hiResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB)));
16031 assign(loResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB2)));
16056 assign(tempResult, unop(op, getVSReg(XB)));
16057 assign( hi64, unop(Iop_V128HIto64, mkexpr(tempResult)) );
16058 assign( lo64, unop(Iop_V128to64, mkexpr(tempResult)) );
16059 assign( res3, unop(Iop_64HIto32, mkexpr(hi64)) );
16060 assign( res2, unop(Iop_64to32, mkexpr(hi64)) );
16061 assign( res1, unop(Iop_64HIto32, mkexpr(lo64)) );
16062 assign( res0, unop(Iop_64to32, mkexpr(lo64)) );
16379 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
16380 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
16381 assign(frA2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XA ))));
16382 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XB ))));
16417 assign( hiResult,
16420 assign( loResult,
16433 assign( hiResult,
16436 assign( loResult,
16496 assign(frT, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XT ) ) ) );
16497 assign(frT2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg( XT ) ) ) );
16499 assign( hiResult,
16506 assign( loResult,
16532 assign( frBHi_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
16533 assign( frBLo_I64, unop(Iop_V128to64, getVSReg( XB )) );
16539 assign( flagsHi,
16544 assign( flagsLo,
16567 assign( frAHi_I64, unop(Iop_V128HIto64, getVSReg( XA )) );
16568 assign( frALo_I64, unop(Iop_V128to64, getVSReg( XA )) );
16569 assign( frBHi_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
16570 assign( frBLo_I64, unop(Iop_V128to64, getVSReg( XB )) );
16577 assign( flagsHi,
16582 assign( flagsLo,
16663 assign( res0,
16667 assign( res1,
16671 assign( res2,
16675 assign( res3,
16696 assign( res0,
16700 assign( res1,
16704 assign( res2,
16708 assign( res3,
16767 assign( res0,
16775 assign( res1,
16783 assign( res2,
16791 assign( res3,
16831 assign( flags0,
16836 assign( flags1,
16841 assign( flags2,
16846 assign( flags3,
16886 assign( flags0,
16891 assign( flags1,
16896 assign( flags2,
16901 assign( flags3,
16936 assign( vB, getVReg(vRB_addr));
17049 assign(bits0_63, unop( Iop_V128to64, mkexpr( vB ) ) );
17050 assign(bits64_127, unop( Iop_V128HIto64, mkexpr( vB ) ) );
17103 assign( vA, getVReg(vRA_addr) );
17104 assign( tmp_hi[0], mkU64( 0 ) );
17105 assign( tmp_lo[0], mkU64( 0 ) );
17117 assign( index_dword_hi[j],
17125 assign( index_dword_lo[j],
17133 assign( index_dword_hi_valid[j],
17139 assign( index_dword_lo_valid[j],
17144 assign( pb_dword_hi[j],
17156 assign( pb_dword_lo[j],
17168 assign( tmp_hi[j+1],
17177 assign( tmp_lo[j+1],
17233 assign(ccIR, ccIR_expr);
17234 assign( condcode,
17272 assign( frA_isNaN, is_NaN( Ity_I64, frA_I64 ) );
17273 assign( frB_isNaN, is_NaN( Ity_I64, frB_I64 ) );
17275 assign( frA_isSNaN,
17282 assign( frB_isSNaN,
17289 assign( frA_isQNaN,
17291 assign( frB_isQNaN,
17365 assign( frA_isZero, is_Zero( Ity_I64, frA_I64 ) );
17366 assign( frB_isZero, is_Zero( Ity_I64, frB_I64 ) );
17367 assign( anyNaN, mkOR1( is_NaN( Ity_I64, frA_I64 ),
17444 assign(frB, unop(Iop_ReinterpI64asF64, mkexpr(frB_I64)));
17445 assign( intermediateResult,
17454 assign( frD,
17487 assign( is_SNAN,
17529 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
17530 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
17535 assign( sqrtHi,
17539 assign( sqrtLo,
17585 assign( sqrt3, binop( Iop_SqrtF64, rm, mkexpr( b3 ) ) );
17586 assign( sqrt2, binop( Iop_SqrtF64, rm, mkexpr( b2 ) ) );
17587 assign( sqrt1, binop( Iop_SqrtF64, rm, mkexpr( b1 ) ) );
17588 assign( sqrt0, binop( Iop_SqrtF64, rm, mkexpr( b0 ) ) );
17591 assign( res0,
17598 assign( res1,
17605 assign( res2,
17612 assign( res3,
17651 assign( a0_I64, unop( Iop_ReinterpF64asI64, mkexpr( a0 ) ) );
17652 assign( b0_I64, unop( Iop_ReinterpF64asI64, mkexpr( b0 ) ) );
17653 assign( a1_I64, unop( Iop_ReinterpF64asI64, mkexpr( a1 ) ) );
17654 assign( b1_I64, unop( Iop_ReinterpF64asI64, mkexpr( b1 ) ) );
17655 assign( a2_I64, unop( Iop_ReinterpF64asI64, mkexpr( a2 ) ) );
17656 assign( b2_I64, unop( Iop_ReinterpF64asI64, mkexpr( b2 ) ) );
17657 assign( a3_I64, unop( Iop_ReinterpF64asI64, mkexpr( a3 ) ) );
17658 assign( b3_I64, unop( Iop_ReinterpF64asI64, mkexpr( b3 ) ) );
17659 assign( res0,
17664 assign( res1,
17669 assign( res2,
17674 assign( res3,
17695 assign(frA, unop(Iop_V128HIto64, getVSReg( XA )));
17696 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
17697 assign(frA2, unop(Iop_V128to64, getVSReg( XA )));
17698 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
17711 assign(frA, unop(Iop_V128HIto64, getVSReg( XA )));
17712 assign(frB, unop(Iop_V128HIto64, getVSReg( XB )));
17713 assign(frA2, unop(Iop_V128to64, getVSReg( XA )));
17714 assign(frB2, unop(Iop_V128to64, getVSReg( XB )));
17749 assign( resHi,
17766 assign( resLo,
17794 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
17795 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg(XB))));
17799 assign(abs_resultHi, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB ) ) ) );
17800 assign(abs_resultLo, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB2 ) ) ) );
17803 assign(abs_resultHi, unop( Iop_AbsF64, mkexpr( frB ) ) );
17804 assign(abs_resultLo, unop( Iop_AbsF64, mkexpr( frB2 ) ) );
17823 assign( shiftVector,
17827 assign( absVal_vector,
17835 assign( signBit_vector,
17856 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
17857 assign(frB2, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, getVSReg(XB))));
17878 assign( frBHi_I64, unop( Iop_V128HIto64, getVSReg( XB ) ) );
17880 assign( frBLo_I64, unop( Iop_V128to64, getVSReg( XB ) ) );
17936 assign(b3_I64, unop(Iop_ReinterpF64asI64, mkexpr(b3_F64)));
17937 assign(b2_I64, unop(Iop_ReinterpF64asI64, mkexpr(b2_F64)));
17938 assign(b1_I64, unop(Iop_ReinterpF64asI64, mkexpr(b1_F64)));
17939 assign(b0_I64, unop(Iop_ReinterpF64asI64, mkexpr(b0_F64)));
17989 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
17990 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
18050 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18068 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18085 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18103 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18127 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18129 assign( maddResult, unop( Iop_ReinterpF64asI64, qop( Iop_MAddF64, rm,
18147 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18149 assign( maddResult,
18171 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18173 assign( msubResult,
18195 assign( frT, unop( Iop_ReinterpI64asF64, unop( Iop_V128HIto64,
18197 assign(msubResult, unop( Iop_ReinterpF64asI64,
18262 assign( frA_I64, unop( Iop_ReinterpF64asI64, mkexpr( frA ) ) );
18263 assign( frB_I64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
18275 assign( frB_I64, unop(Iop_V128HIto64, getVSReg( XB )) );
18280 assign( flags,
18318 assign(frA, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XA ))));
18319 assign(frB, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, getVSReg( XB ))));
18356 assign(frA_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vA ))));
18357 assign(frB_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vB ))));
18358 assign(frA_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vA ))));
18359 assign(frB_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vB ))));
18369 assign( hiResult,
18372 assign( loResult,
18381 assign(hi_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 2 ) ),
18383 assign( hiResult,unop( Iop_1Sto64, mkexpr( hi_GE ) ) );
18385 assign(lo_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 2 ) ),
18387 assign( loResult, unop( Iop_1Sto64, mkexpr( lo_GE ) ) );
18391 assign( hiEQlo,
18398 assign( all_elem_true,
18406 assign( all_elem_false,
18413 assign( ccPPC32,
18443 assign( vA, getVSReg( XA ) );
18444 assign( vB, getVSReg( XB ) );
18477 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
18491 assign
18505 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
18539 assign( vA, getVSReg( XA ) );
18540 assign( vB, getVSReg( XB ) );
18582 assign( vA_hi, unop( Iop_V128HIto64, mkexpr( vA ) ) );
18583 assign( vB_hi, unop( Iop_V128HIto64, mkexpr( vB ) ) );
18614 assign( eq_lt_gt, binop( Iop_Or32,
18625 assign(CC, binop( Iop_Or32,
18663 assign( vT, getVSReg( XT ) );
18664 assign( tmp, binop( Iop_AndV128,
18695 assign( hi64, unop( Iop_V128HIto64, mkexpr(vB) ) );
18696 assign( lo64, unop( Iop_V128to64, mkexpr(vB) ) );
18697 assign( absVal, binop( Iop_64HLtoV128,
18702 assign(absVal, binop(Iop_ShrV128,
18724 assign( rT, binop( Iop_Shr64,
18735 assign( tmp, unop( Iop_V128HIto64, mkexpr( vB ) ) );
18744 assign( rT, binop( Iop_Or64,
18763 assign( result, unop( Iop_F16toF64x2, mkexpr( vB ) ) );
18767 assign( value, unop( Iop_V128HIto64, mkexpr( result ) ) );
18779 assign( result, unop( Iop_F64toF16x2, mkexpr( vB ) ) );
18780 assign( value, unop( Iop_64to32, unop( Iop_V128HIto64,
18815 assign( vB_hi, unop( Iop_V128HIto64, mkexpr( vB ) ) );
18817 assign( pos, unop( Iop_1Uto64,
18824 assign( NaN, unop( Iop_1Uto64, is_NaN( Ity_I64, vB_hi ) ) );
18825 assign( inf, unop( Iop_1Uto64, is_Inf( Ity_I64, vB_hi ) ) );
18826 assign( zero, unop( Iop_1Uto64, is_Zero( Ity_I64, vB_hi ) ) );
18836 assign( tmp,
18842 assign( not_sp, unop( Iop_1Uto64,
18846 assign( exponent,
18852 assign( dnorm, unop( Iop_1Uto64,
18863 assign( not_sp, mkU64( 0 ) );
18864 assign( dnorm, unop( Iop_1Uto64, is_Denorm( Ity_I64, vB_hi ) ) );
18867 assign( DCM, create_DCM( Ity_I64, NaN, inf, zero, dnorm, pos ) );
18868 assign( CC,
18897 assign( vecA_signed, binop( Iop_And64,
18901 assign( vecB_unsigned, binop( Iop_And64,
18905 assign( vec_result, binop( Iop_64HLtoV128,
18918 assign( BHi_signed, binop( Iop_Or64,
18935 assign( BHi_signed, unop( Iop_V128HIto64, mkexpr(vB) ) );
18936 assign( BHi_unsigned, binop( Iop_And64, mkexpr(BHi_signed),
18938 assign( BHi_negated_signbit,
18948 assign( BHi_negated,
18957 assign( vec_result, binop( Iop_64HLtoV128, mkexpr(BHi_negated),
18970 assign(frA, unop(Iop_V128HIto64, mkexpr( vA )));
18971 assign(frB, unop(Iop_V128HIto64, mkexpr( vB )));
18985 assign(frB_I64, unop(Iop_V128HIto64, mkexpr( vB )));
19008 assign( frB,
19013 assign( sqrt,
19040 assign( frB,
19045 assign( sqrt,
19065 assign( frB,
19108 assign( value[i],
19119 assign( pos[i], unop( Iop_1Uto32,
19126 assign( NaN[i], unop( Iop_1Uto32, is_NaN( Ity_I32, value[i] ) ));
19127 assign( inf[i], unop( Iop_1Uto32, is_Inf( Ity_I32, value[i] ) ) );
19128 assign( zero[i], unop( Iop_1Uto32, is_Zero( Ity_I32, value[i] ) ) );
19130 assign( dnorm[i], unop( Iop_1Uto32, is_Denorm( Ity_I32,
19132 assign( DCM[i], create_DCM( Ity_I32, NaN[i], inf[i], zero[i],
19135 assign( match_value[i],
19164 assign( new_XT[0], binop( Iop_64HLtoV128,
19172 assign( A_value[i],
19182 assign( B_value[i],
19203 assign( new_XT[i+1],
19231 assign( rA, getIReg(rA_addr));
19232 assign( rB, getIReg(rB_addr));
19280 assign( new_XT[0], binop( Iop_64HLtoV128,
19286 assign( value[i],
19305 assign( new_XT[i+1],
19329 assign( sub_element0,
19337 assign( sub_element1,
19369 assign( new_XT[0], binop( Iop_64HLtoV128,
19375 assign( value[i],
19396 assign( new_value[i],
19406 assign( new_XT[i+1],
19427 assign( sub_element0,
19435 assign( sub_element1,
19443 assign( sub_element2,
19451 assign( sub_element3,
19478 assign( new_xT[0], binop( Iop_64HLtoV128,
19487 assign( sub_element[i],
19496 assign( sub_element[i+4],
19506 assign( new_xT[i+1],
19537 assign( src,
19545 assign( result, unop( Iop_F16toF32x4, mkexpr( src ) ) );
19562 assign( tmp64, unop( Iop_F32toF16x4, mkexpr( vB ) ) );
19572 assign( result,
19581 assign( result,
19601 assign( new_xT[0], binop( Iop_64HLtoV128,
19610 assign( sub_element[i],
19620 assign( sub_element[i+8],
19630 assign( new_xT[i+1],
19672 assign( value[i],
19682 assign( pos[i], unop( Iop_1Uto64,
19689 assign( NaN[i], unop( Iop_1Uto64, is_NaN( Ity_I64, value[i] ) ) );
19690 assign( inf[i], unop( Iop_1Uto64, is_Inf( Ity_I64, value[i] ) ) );
19691 assign( zero[i], unop( Iop_1Uto64, is_Zero( Ity_I64, value[i] ) ) );
19692 assign( dnorm[i], unop( Iop_1Uto64, is_Denorm( Ity_I64,
19695 assign( DCM[i], create_DCM( Ity_I64, NaN[i], inf[i], zero[i],
19698 assign( match_value[i],
19722 assign( new_XT[0], binop( Iop_64HLtoV128,
19730 assign( A_value[i],
19739 assign( B_value[i],
19759 assign( new_XT[i+1],
19802 assign( vA, getVSReg( XA ) );
19803 assign( vB, getVSReg( XB ) );
19875 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
19925 assign( word[i], unop( Iop_32Uto64,
19949 assign( word[i], unop( Iop_32Uto64,
19989 assign( base_addr, ea_rAor0( rA_addr ) );
19990 assign( tmp_low[0], mkU64( 0 ) );
19991 assign( tmp_hi[0], mkU64( 0 ) );
19994 assign( nb_not_zero, unop( Iop_1Sto64,
20001 assign( nb_gt16, unop( Iop_1Sto8,
20011 assign( shift,
20034 assign( byte[i], binop( Iop_Shl64,
20039 assign( tmp_hi[i+1], binop( Iop_Or64,
20053 assign( byte[i+8], binop( Iop_Shl64,
20058 assign( tmp_low[i+1], binop( Iop_Or64,
20062 assign( ld_result, binop( Iop_ShlV128,
20079 assign( byte[i], binop( Iop_Shl64,
20084 assign( tmp_low[i+1],
20098 assign( byte[i+8], binop( Iop_Shl64,
20103 assign( tmp_hi[i+1], binop( Iop_Or64,
20107 assign( ld_result, binop( Iop_ShrV128,
20150 assign( rB, getIReg(rB_addr));
20151 assign( base_addr, ea_rAor0( rA_addr ) );
20152 assign( tmp_low[0], mkU64( 0 ) );
20153 assign( tmp_hi[0], mkU64( 0 ) );
20156 assign( nb, binop( Iop_Shr64, mkexpr( rB ), mkU8( 56 ) ) );
20158 assign( nb_compare_zero, unop( Iop_1Sto64,
20164 assign( nb_zero, binop( Iop_64HLtoV128,
20168 assign( mask_shift, binop( Iop_Sub64,
20184 assign( byte[i], binop( Iop_Shl64,
20188 assign( tmp_hi[i+1],
20202 assign( byte[i+8], binop( Iop_Shl64,
20206 assign( tmp_low[i+1], binop( Iop_Or64,
20214 assign( mask, binop( Iop_AndV128,
20246 assign( data, binop( Iop_And64,
20251 assign( data, binop( Iop_And64,
20361 assign( data, load( Ity_I64, mkexpr( EA ) ) );
20379 assign( perm_LE, binop( Iop_64HLtoV128, mkU64(0x0c0d0e0f08090a0bULL),
20404 assign( tmp_low[0], mkU64( 0 ) );
20405 assign( tmp_hi[0], mkU64( 0 ) );
20415 assign( h_word[i], binop( Iop_Shl64,
20420 assign( tmp_low[i+1],
20433 assign( h_word[i+4], binop( Iop_Shl64,
20438 assign( tmp_hi[i+1], binop( Iop_Or64,
20460 assign( tmp_low[0], mkU64( 0 ) );
20461 assign( tmp_hi[0], mkU64( 0 ) );
20471 assign( byte[i], binop( Iop_Shl64,
20476 assign( tmp_low[i+1],
20489 assign( byte[i+8], binop( Iop_Shl64,
20493 assign( tmp_hi[i+1], binop( Iop_Or64,
20533 assign( vS, getVSReg( XS ) );
20544 assign( tmp, unop( Iop_64to32, getIReg(rA_addr) ) );
20545 assign( vS, binop( Iop_64HLtoV128,
20564 assign( rA, mkU64 ( 0 ) );
20566 assign( rA, getIReg(rA_addr) );
20568 assign( rB, getIReg(rB_addr) );
20569 assign( vS, binop( Iop_64HLtoV128, mkexpr( rA ), mkexpr( rB ) ) );
20604 assign( EA, ea_rAor0_idxd( rA_addr, rB_addr ) );
20605 assign( vS, getVSReg( XS ) );
20631 assign( word0, binop( Iop_Shr64,
20635 assign( word1, binop( Iop_And64,
20639 assign( word2, binop( Iop_Shr64,
20643 assign( word3, binop( Iop_And64,
20710 assign( nb_field, binop( Iop_Shr64,
20714 assign( nb, unop( Iop_64to8, mkexpr( nb_field ) ) );
20717 assign( nb_gt16, unop( Iop_1Sto8,
20725 assign( nb_zero, binop( Iop_64HLtoV128,
20736 assign( n_bytes, binop( Iop_And8, mkexpr( nb ), mkexpr( nb_gt16 ) ) );
20737 assign( shift, unop( Iop_64to8,
20750 assign( base_addr, ea_rAor0( rA_addr ) );
20752 assign( current_mem,
20769 assign( nb_mask,
20780 assign( store_val,
20792 assign( nb_mask,
20805 assign( store_val,
20820 assign( word0, binop( Iop_Shr64,
20824 assign( word1, binop( Iop_And64,
20828 assign( word2, binop( Iop_Shr64,
20832 assign( word3, binop( Iop_And64,
20889 assign( nb_field, binop( Iop_Shr64,
20892 assign( nb, unop( Iop_64to8, mkexpr( nb_field ) ) );
20893 assign( mask, mkU64( 0xFFFFFFFFFFFFFFFFULL ) );
20896 assign( nb_gt16, unop( Iop_1Sto8,
20903 assign( nb_field_compare_zero, unop( Iop_1Sto64,
20909 assign( nb_zero, binop( Iop_64HLtoV128,
20915 assign( n_bytes, binop( Iop_And8, mkexpr( nb ), mkexpr( nb_gt16 ) ) );
20916 assign( shift,
20929 assign( base_addr, ea_rAor0( rA_addr ) );
20932 assign( word0[0], mkU64( 0 ) );
20935 assign( word1[0], mkU64( 0 ) );
20938 assign( word2[0], mkU64( 0 ) );
20941 assign( word3[0], mkU64( 0 ) );
20951 assign( word0[i+1],
20969 assign( word1[i+1],
20986 assign( word2[i+1],
21003 assign( word3[i+1],
21014 assign( current_mem,
21035 assign( nb_mask,
21052 assign( store_val,
21064 assign( tmp_low[0], mkU64( 0 ) );
21065 assign( tmp_hi[0], mkU64( 0 ) );
21073 assign( byte[i], binop( Iop_And64,
21079 assign( byte[i+8], binop( Iop_And64,
21086 assign( tmp_low[i+1],
21090 assign( tmp_hi[i+1],
21130 assign(high64, unop( Iop_ReinterpI64asF64,
21132 assign(val32, unop( Iop_ReinterpF32asI32,
21158 assign( byte_to_store, binop( Iop_And64,
21182 assign( byte_to_store, binop( Iop_And64,
21217 assign( hi64, unop( Iop_V128HIto64, mkexpr( vS ) ) );
21218 assign( lo64, unop( Iop_V128to64, mkexpr( vS ) ) );
21250 assign( half_word0, binop( Iop_Shr64,
21254 assign( half_word1, binop( Iop_And64,
21260 assign( half_word2, binop( Iop_And64,
21266 assign( half_word3, binop( Iop_And64,
21270 assign( half_word4, binop( Iop_Shr64,
21274 assign( half_word5, binop( Iop_And64,
21280 assign( half_word6, binop( Iop_And64,
21286 assign( half_word7, binop( Iop_And64,
21387 assign( byte[i], binop( Iop_And64,
21393 assign( byte[i+8], binop( Iop_And64,
21475 assign( vB, getF128Reg( vB_addr ) );
21493 assign( vT, binop( Iop_F128toI128S, rm, mkexpr( vB ) ) );
21497 assign( vT, binop( Iop_F128toI128S, rm, mkexpr( vB ) ) );
21514 assign( vT, binop( Iop_RndF128, rm, mkexpr( vB ) ) );
21545 assign( vB, getF128Reg( vB_addr ) );
21554 assign( vA, getF128Reg( vA_addr ) );
21559 assign( vT, triop( Iop_AddF128, rm, mkexpr( vA ), mkexpr( vB ) ) );
21564 assign( vT, triop( Iop_AddF128, set_round_to_Oddmode(),
21572 assign( vA, getF128Reg( vA_addr ) );
21577 assign( vT, triop( Iop_MulF128, rm, mkexpr( vA ), mkexpr( vB ) ) );
21582 assign( vT, triop( Iop_MulF128, set_round_to_Oddmode(), mkexpr( vA ),
21593 assign( vA, getF128Reg( vA_addr ) );
21594 assign( vC, getF128Reg( vT_addr ) );
21599 assign( vT,
21606 assign( vT,
21617 assign( vA, getF128Reg( vA_addr ) );
21618 assign( vC, getF128Reg( vT_addr ) );
21623 assign( vT,
21630 assign( vT,
21641 assign( vA, getF128Reg( vA_addr ) );
21642 assign( vC, getF128Reg( vT_addr ) );
21647 assign( vT,
21654 assign( vT,
21665 assign( vA, getF128Reg( vA_addr ) );
21666 assign( vC, getF128Reg( vT_addr ) );
21671 assign( vT,
21678 assign( vT,
21687 assign( vA, getF128Reg( vA_addr ) );
21691 assign( vT, triop( Iop_SubF128, rm, mkexpr( vA ), mkexpr( vB ) ) );
21696 assign( vT, triop( Iop_SubF128, set_round_to_Oddmode(), mkexpr( vA ),
21704 assign( vA, getF128Reg( vA_addr ) );
21708 assign( vT, triop( Iop_DivF128, rm, mkexpr( vA ), mkexpr( vB ) ) );
21713 assign( vT, triop( Iop_DivF128, set_round_to_Oddmode(), mkexpr( vA ),
21729 assign( vT, binop( Iop_SqrtF128, rm, mkexpr( vB ) ) );
21734 assign( vT, binop( Iop_SqrtF128, set_round_to_Oddmode(),
21756 assign( vT, unop( Iop_TruncF128toI32U, mkexpr( vB ) ) );
21765 assign( tmp, unop( Iop_ReinterpF64asI64,
21767 assign( vT, unop( Iop_I64UtoF128, mkexpr( tmp ) ) );
21775 assign( vT, unop( Iop_TruncF128toI32S, mkexpr( vB ) ) );
21785 assign( tmp, unop( Iop_ReinterpF64asI64,
21787 assign( vT, unop( Iop_I64StoF128, mkexpr( tmp ) ) );
21795 assign( vT, unop( Iop_TruncF128toI64U, mkexpr( vB ) ) );
21813 assign( ftmp, binop( Iop_F128toF64, rm, mkexpr( vB ) ) );
21818 assign( ftmp,
21827 assign( vT,
21832 assign( vT,
21837 assign( tmp, unop( Iop_ReinterpF64asI64,
21848 assign( vT, unop( Iop_F64toF128,
21858 assign( vT, unop( Iop_TruncF128toI64S, mkexpr( vB ) ) );
21895 assign( vB, getVSReg( vB_addr ) );
21911 assign( vA, getVSReg(vA_addr) );
21913 assign( sign_vA, binop( Iop_And64,
21917 assign( vB_hi, binop( Iop_Or64,
21923 assign( vT, binop( Iop_64HLtoV128,
21946 assign( vA, getVSReg(vA_addr));
21997 assign( eq_lt_gt,
22020 assign(CC, binop( Iop_Or32,
22044 assign( vA, getVSReg(vA_addr));
22082 assign( eq_lt_gt, binop( Iop_Or32,
22093 assign(CC, binop( Iop_Or32,
22121 assign( zero, unop( Iop_1Uto64, is_Zero( Ity_V128, vB ) ) );
22122 assign( pos, unop( Iop_1Uto64,
22130 assign( NaN, unop( Iop_1Uto64, is_NaN( Ity_V128, vB ) ) );
22131 assign( inf, unop( Iop_1Uto64, is_Inf( Ity_V128, vB ) ) );
22133 assign( dnorm, unop( Iop_1Uto64, is_Denorm( Ity_V128, vB ) ) );
22134 assign( DCM, create_DCM( Ity_I64, NaN, inf, zero, dnorm, pos ) );
22135 assign( CC, binop( Iop_Or64,
22167 assign( vT, binop( Iop_AndV128, mkexpr( vB ),
22175 assign( vT, binop( Iop_ShrV128,
22185 assign( vT, binop( Iop_OrV128, mkexpr( vB ),
22193 assign( vT, binop( Iop_XorV128, mkexpr( vB ),
22206 assign( expZero, unop( Iop_1Uto64,
22214 assign( expInfinity,
22226 assign( vT,
22255 assign( vA, getVSReg( vA_addr ) );
22256 assign( exp, binop( Iop_And64,
22260 assign( vT, binop( Iop_64HLtoV128,
22304 assign( vA, getVSReg( XA ) );
22305 assign( vB, getVSReg( XB ) );
22315 assign( hi, binop(Iop_ShlV128, mkexpr(vA), mkU8(SHW*32)) );
22316 assign( lo, binop(Iop_ShrV128, mkexpr(vB), mkU8(128-SHW*32)) );
22317 assign ( result, binop(Iop_OrV128, mkexpr(hi), mkexpr(lo)) );
22319 assign ( result, mkexpr(vA) );
22331 assign( hi, unop(Iop_V128to64, mkexpr(vA)) );
22333 assign( hi, unop(Iop_V128HIto64, mkexpr(vA)) );
22336 assign( lo, unop(Iop_V128to64, mkexpr(vB)) );
22338 assign( lo, unop(Iop_V128HIto64, mkexpr(vB)) );
22340 assign( vT, binop(Iop_64HLtoV128, mkexpr(hi), mkexpr(lo)) );
22358 assign( a64, unop(word_op, mkexpr(vA)) );
22359 assign( ahi32, unop(Iop_64HIto32, mkexpr(a64)) );
22360 assign( alo32, unop(Iop_64to32, mkexpr(a64)) );
22362 assign( b64, unop(word_op, mkexpr(vB)) );
22363 assign( bhi32, unop(Iop_64HIto32, mkexpr(b64)) );
22364 assign( blo32, unop(Iop_64to32, mkexpr(b64)) );
22366 assign( vT, binop(Iop_64HLtoV128,
22378 assign( vC, getVSReg( XC ) );
22410 assign( vT, getVSReg( XT ) );
22412 assign( new_Vt[0], binop( Iop_64HLtoV128,
22414 assign( perm_mask, binop( Iop_64HLtoV128,
22416 assign( val_mask, binop( Iop_64HLtoV128,
22436 assign( perm_val[i], binop( Iop_ShrV128,
22446 assign( perm_val[i],
22464 assign( perm_val_gt16[i],
22479 assign( perm_idx[i],
22494 assign( tmp_val[i],
22516 assign( new_Vt[i+1], binop( Iop_OrV128,
22565 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
22566 assign( EA_align16, addr_align( mkexpr(EA), 16 ) );
22731 assign( vS, getVReg(vS_addr));
22732 assign( EA, ea_rAor0_idxd(rA_addr, rB_addr) );
22737 assign( eb, binop(Iop_And8, mkU8(0xF),
22741 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
22743 assign( idx, binop(Iop_Shl8,
22754 assign( addr_aligned, addr_align(mkexpr(EA), 2) );
22755 assign( eb, binop(Iop_And8, mkU8(0xF),
22758 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
22760 assign( idx, binop(Iop_Shl8,
22771 assign( addr_aligned, addr_align(mkexpr(EA), 4) );
22772 assign( eb, binop(Iop_And8, mkU8(0xF),
22775 assign( idx, binop(Iop_Shl8, mkexpr(eb), mkU8(3)) );
22777 assign( idx, binop(Iop_Shl8,
22832 assign( vA, getVReg( vA_addr ) );
22833 assign( vB, getVReg( vB_addr ) );
23180 assign( z3, binop(Iop_Add64, mkexpr(b3),
23184 assign( z2, binop(Iop_Add64, mkexpr(b2),
23188 assign( z1, binop(Iop_Add64, mkexpr(b1),
23192 assign( z0, binop(Iop_Add64, mkexpr(b0),
23220 assign( z3, binop(Iop_Add64, mkexpr(b3),
23224 assign( z2, binop(Iop_Add64, mkexpr(b2),
23228 assign( z1, binop(Iop_Add64, mkexpr(b1),
23232 assign( z0, binop(Iop_Add64, mkexpr(b0),
23254 assign( z3, binop(Iop_Add64, mkexpr(b3),
23256 assign( z2, binop(Iop_Add64, mkexpr(b2),
23258 assign( z1, binop(Iop_Add64, mkexpr(b1),
23260 assign( z0, binop(Iop_Add64, mkexpr(b0),
23276 assign( z2, binop(Iop_Add64, mkexpr(b2),
23278 assign( z0, binop(Iop_Add64, mkexpr(b0),
23294 assign( z0, binop(Iop_Add64, mkexpr(b0),
23325 assign( vA, getVReg(vA_addr));
23326 assign( vB, getVReg(vB_addr));
23405 assign( vA, getVReg(vA_addr));
23406 assign( vB, getVReg(vB_addr));
23417 assign( vD, binop(Iop_CmpEQ8x16, mkexpr(vA), mkexpr(vB)) );
23423 assign( vD, unop( Iop_NotV128,
23430 assign( vD, binop(Iop_CmpEQ16x8, mkexpr(vA), mkexpr(vB)) );
23436 assign( vD, unop( Iop_NotV128,
23443 assign( vD, binop(Iop_CmpEQ32x4, mkexpr(vA), mkexpr(vB)) );
23449 assign( vD, unop( Iop_NotV128,
23463 assign( zero, binop( Iop_64HLtoV128, mkU64( 0 ), mkU64( 0 ) ) );
23464 assign( vAeq0, binop( Iop_CmpEQ8x16, mkexpr( vA ), mkexpr( zero ) ) );
23465 assign( vBeq0, binop( Iop_CmpEQ8x16, mkexpr( vB ), mkexpr( zero ) ) );
23466 assign( vAeqvB, unop( Iop_NotV128,
23470 assign( vD, mkOr3_V128( vAeqvB, vAeq0, vBeq0 ) );
23484 assign( zero, binop( Iop_64HLtoV128, mkU64( 0 ), mkU64( 0 ) ) );
23485 assign( vAeq0, binop( Iop_CmpEQ16x8, mkexpr( vA ), mkexpr( zero ) ) );
23486 assign( vBeq0, binop( Iop_CmpEQ16x8, mkexpr( vB ), mkexpr( zero ) ) );
23487 assign( vAeqvB, unop( Iop_NotV128,
23491 assign( vD, binop( Iop_OrV128,
23509 assign( zero, binop( Iop_64HLtoV128, mkU64( 0 ), mkU64( 0 ) ) );
23510 assign( vAeq0, binop( Iop_CmpEQ32x4, mkexpr( vA ), mkexpr( zero ) ) );
23511 assign( vBeq0, binop( Iop_CmpEQ32x4, mkexpr( vB ), mkexpr( zero ) ) );
23512 assign( vAeqvB, unop( Iop_NotV128,
23516 assign( vD, binop( Iop_OrV128,
23527 assign( vD, binop(Iop_CmpEQ64x2, mkexpr(vA), mkexpr(vB)) );
23533 assign( vD, binop(Iop_CmpGT8Ux16, mkexpr(vA), mkexpr(vB)) );
23539 assign( vD, binop(Iop_CmpGT16Ux8, mkexpr(vA), mkexpr(vB)) );
23545 assign( vD, binop(Iop_CmpGT32Ux4, mkexpr(vA), mkexpr(vB)) );
23551 assign( vD, binop(Iop_CmpGT64Ux2, mkexpr(vA), mkexpr(vB)) );
23557 assign( vD, binop(Iop_CmpGT8Sx16, mkexpr(vA), mkexpr(vB)) );
23563 assign( vD, binop(Iop_CmpGT16Sx8, mkexpr(vA), mkexpr(vB)) );
23569 assign( vD, binop(Iop_CmpGT32Sx4, mkexpr(vA), mkexpr(vB)) );
23575 assign( vD, binop(Iop_CmpGT64Sx2, mkexpr(vA), mkexpr(vB)) );
23628 assign( vA, getVReg(vA_addr));
23629 assign( vB, getVReg(vB_addr));
23630 assign( vC, getVReg(vC_addr));
23631 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
23644 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)));
23645 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
23646 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
23647 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
23648 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
23649 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
23650 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
23652 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
23658 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
23673 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)) );
23674 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
23675 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
23676 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
23677 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
23678 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
23679 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
23682 assign( zKonst, binop(Iop_ShlN32x4, unop(Iop_Dup32x4, mkU32(0x1)),
23685 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
23692 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
23706 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
23707 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
23708 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vC)));
23709 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
23710 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
23711 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vC)));
23712 assign(zLo, binop(Iop_Add32x4,
23715 assign(zHi, binop(Iop_Add32x4,
23748 assign ( mul_result0, binop( Iop_MullU64,
23752 assign ( mul_result1, binop( Iop_MullU64,
23759 assign ( partial_sum_low, binop( Iop_Add64,
23771 assign ( partial_sum_hi,
23779 assign ( result_low, binop( Iop_Add64,
23791 assign ( result_hi,
23811 assign( abEvn, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
23812 assign( abOdd, binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)) );
23841 assign( abEE, MK_Iop_MullOdd16Sx8( mkexpr(aEvn), mkexpr(bEvn) ));
23842 assign( abEO, binop(Iop_MullEven16Sx8, mkexpr(aEvn), mkexpr(bEvn)) );
23843 assign( abOE, MK_Iop_MullOdd16Sx8( mkexpr(aOdd), mkexpr(bOdd) ));
23844 assign( abOO, binop(Iop_MullEven16Sx8, mkexpr(aOdd), mkexpr(bOdd)) );
23857 assign( abEvn, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
23858 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
23868 assign( abEvn, MK_Iop_MullOdd16Ux8(mkexpr(vA), mkexpr(vB) ));
23869 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
23877 assign( z3, binop(Iop_Add64, mkexpr(c3),
23879 assign( z2, binop(Iop_Add64, mkexpr(c2),
23881 assign( z1, binop(Iop_Add64, mkexpr(c1),
23883 assign( z0, binop(Iop_Add64, mkexpr(c0),
23895 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
23896 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
23906 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
23907 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
23915 assign( z3, binop(Iop_Add64, mkexpr(c3),
23917 assign( z2, binop(Iop_Add64, mkexpr(c2),
23919 assign( z1, binop(Iop_Add64, mkexpr(c1),
23921 assign( z0, binop(Iop_Add64, mkexpr(c0),
23952 assign( vA, getVReg(vA_addr));
23953 assign( vB, getVReg(vB_addr));
23954 assign( vC, getVReg(vC_addr));
24004 assign( vA, getVReg(vA_addr));
24005 assign( vB, getVReg(vB_addr));
24059 assign( sh, binop(Iop_And8, mkU8(0x7),
24069 assign( sh, binop(Iop_And8, mkU8(0x78),
24097 assign( sh, binop(Iop_And8, mkU8(0x7),
24127 assign( sh, binop(Iop_And8, mkU8(0x78),
24169 assign( vA, getVReg(vA_addr));
24170 assign( vB, getVReg(vB_addr));
24171 assign( vC, getVReg(vC_addr));
24198 assign( vC_andF,
24201 assign( a_perm,
24203 assign( b_perm,
24206 assign( mask, binop(Iop_SarN8x16,
24241 assign( vrc_b, binop( Iop_AndV128, mkexpr( vC ),
24243 assign( vrc_a, binop( Iop_ShrV128,
24247 assign( a_perm, binop( Iop_Perm8x16, mkexpr( vA ), mkexpr( vrc_a ) ) );
24248 assign( b_perm, binop( Iop_Perm8x16, mkexpr( vB ), mkexpr( vrc_b ) ) );
24265 assign( new_Vt[0], binop( Iop_64HLtoV128,
24276 assign( index[i],
24294 assign( index_gt16[i],
24306 assign( mask[i],
24325 assign( tmp[i],
24349 assign( new_Vt[i+1], binop( Iop_OrV128,
24499 assign( vD, getVReg( vD_addr ) );
24501 assign( shift, unop( Iop_32to8,
24536 assign( vD, getVReg( vD_addr ) );
24538 assign( shift, unop( Iop_32to8,
24573 assign( vD, getVReg( vD_addr ) );
24575 assign( shift, unop( Iop_32to8,
24610 assign( vD, getVReg( vD_addr ) );
24612 assign( shift, unop( Iop_32to8,
24732 assign( vA, getVReg( vA_addr ) );
24733 assign( vB, getVReg( vB_addr ) );
24748 assign( vMask, binop( Iop_CmpGT8Ux16, mkexpr( vA ), mkexpr( vB ) ) );
24750 assign( vAminusB,
24755 assign( vBminusA,
24760 assign( vT, binop( Iop_OrV128,
24773 assign( vMask, binop( Iop_CmpGT16Ux8, mkexpr( vA ), mkexpr( vB ) ) );
24775 assign( vAminusB,
24780 assign( vBminusA,
24785 assign( vT, binop( Iop_OrV128,
24798 assign( vMask, binop( Iop_CmpGT32Ux4, mkexpr( vA ), mkexpr( vB ) ) );
24800 assign( vAminusB,
24805 assign( vBminusA,
24810 assign( vT, binop( Iop_OrV128,
24838 assign( vA, getVReg(vA_addr));
24854 assign( vB, getVReg(vB_addr));
24869 assign( vB, getVReg(vB_addr));
24898 assign( vA, getVReg(vA_addr));
24899 assign( vB, getVReg(vB_addr));
24940 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
24944 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
24960 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
24964 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
24999 assign( a1, binop(Iop_ShlN16x8,
25002 assign( a2, binop(Iop_ShlN16x8,
25005 assign( a3, binop(Iop_ShrN16x8,
25008 assign( a_tmp, binop(Iop_OrV128, mkexpr(a1),
25011 assign( b1, binop(Iop_ShlN16x8,
25014 assign( b2, binop(Iop_ShlN16x8,
25017 assign( b3, binop(Iop_ShrN16x8,
25020 assign( b_tmp, binop(Iop_OrV128, mkexpr(b1),
25050 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
25054 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
25082 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
25088 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
25095 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
25102 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
25109 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
25124 assign( z0, binop(Iop_ShlN16x8,
25127 assign( z1, binop(Iop_ShrN16x8,
25130 assign( z01, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
25132 assign( z2, binop(Iop_ShrN16x8,
25137 assign( z3, binop(Iop_ShrN16x8,
25140 assign( z23, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
25157 assign( z0, binop(Iop_ShlN16x8,
25160 assign( z1, binop(Iop_ShrN16x8,
25163 assign( z01, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
25165 assign( z2, binop(Iop_ShrN16x8,
25170 assign( z3, binop(Iop_ShrN16x8,
25173 assign( z23, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
25183 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
25190 assign( signs, binop(Iop_CmpGT32Sx4, mkexpr(zeros), mkexpr(vB)) );
25216 assign( vA, getVReg(vA_addr));
25217 assign( vB, getVReg(vB_addr));
25279 assign( vA, getVReg(vRA_addr));
25289 assign( dst, binop( Iop_SHA256, mkexpr( vA ), mkU8( s_field) ) );
25333 assign( carry, cin );
25343 assign(_vecA_32, unop( Iop_64to32, _vecA_low64 ) );
25344 assign(_vecB_32, unop( Iop_64to32, _vecB_low64 ) );
25347 assign(_vecA_32, unop( Iop_64HIto32, _vecA_low64 ) );
25348 assign(_vecB_32, unop( Iop_64HIto32, _vecB_low64 ) );
25351 assign(_vecA_32, unop( Iop_64to32, _vecA_high64 ) );
25352 assign(_vecB_32, unop( Iop_64to32, _vecB_high64 ) );
25355 assign(_vecA_32, unop( Iop_64HIto32, _vecA_high64 ) );
25356 assign(_vecB_32, unop( Iop_64HIto32, _vecB_high64 ) );
25360 assign( res_64, binop( Iop_Add64,
25374 assign(carry, unop( Iop_64HIto32, mkexpr( res_64 ) ) );
25377 assign(res_32, unop( Iop_64to32, mkexpr( res_64 ) ) );
25381 assign(result, binop( Iop_OrV128,
25393 assign(tmp_result, mkexpr(result));
25417 assign( vA, getVReg(vRA_addr));
25418 assign( vB, getVReg(vRB_addr));
25469 assign( idx_tmp,
25475 assign( idx_LT127,
25486 assign( idx,
25493 assign( idx_LT127_ity128,
25498 assign( perm_bit,
25533 assign( vC, getVReg(vRC_addr));
25536 assign(cin, binop( Iop_And32,
25547 assign( vC, getVReg(vRC_addr));
25550 assign(cin, binop( Iop_And32,
25560 assign( vC, getVReg(vRC_addr));
25563 assign(cin, binop( Iop_And32,
25576 assign( vC, getVReg(vRC_addr));
25579 assign(cin, binop( Iop_And32,
25624 assign( mask, unop( Iop_1Sto64,
25659 assign( vA, getVReg(vRA_addr));
25660 assign( vB, getVReg(vRB_addr));
25730 assign( eq_lt_gt,
25749 assign( valid_mask, unop( Iop_1Sto32, unop( Iop_32to1, valid ) ) );
25779 assign( vA, getVReg(vRA_addr));
25780 assign( vB, getVReg(vRB_addr));
25801 assign( dst, bcd_sign_code_adjust( ps,
25807 assign( dst, bcd_sign_code_adjust( ps,
25968 assign( shift_field, unop( Iop_V128to64,
25984 assign( shift_dir_mask, unop( Iop_1Sto64, shift_dir ) );
25987 assign(shift_by,
26017 assign( value_shl,
26020 assign( value_shr,
26034 assign( shifted_out,
26129 assign( round, unop( Iop_1Uto32,
26170 assign( length, binop( Iop_And64,
26189 assign( masked_out,
26498 assign( tmp,
26639 assign( tmp,
26688 assign( tmp,
26763 assign( hword_7, binop( Iop_And64,
26769 assign( tmp, convert_from_national( vbi, mkexpr( vB ) ) );
26913 assign( valid_mask, unop( Iop_1Sto32, unop( Iop_32to1, valid ) ) );
26921 assign( eq_lt_gt,
26966 assign( vA, getVReg(vA_addr));
26967 assign( vB, getVReg(vB_addr));
26968 assign( vC, getVReg(vC_addr));
26976 assign(rm, get_IR_roundingmode());
27085 assign( vA, getVReg(vA_addr));
27086 assign( vB, getVReg(vB_addr));
27097 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
27103 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
27109 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
27119 assign( zeros, unop(Iop_Dup32x4, mkU32(0)) );
27129 assign( gt, unop(Iop_NotV128,
27131 assign( lt, unop(Iop_NotV128,
27138 assign( vD, binop(Iop_ShlN32x4,
27179 assign( vB, getVReg(vB_addr));
27183 assign( vScale, unop(Iop_Dup32x4, mkU32( float_to_bits(scale) )) );
27185 assign( vInvScale,
29575 // assign(n1, mkexpr(arg));
29576 // assign(n2, binop(Iop_Or32, mkexpr(n1), binop(Iop_Shr32, mkexpr(n1), mkU8(1))));
29577 // assign(n3, binop(Iop_Or32, mkexpr(n2), binop(Iop_Shr32, mkexpr(n2), mkU8(2))));
29578 // assign(n4, binop(Iop_Or32, mkexpr(n3), binop(Iop_Shr32, mkexpr(n3), mkU8(4))));
29579 // assign(n5, binop(Iop_Or32, mkexpr(n4), binop(Iop_Shr32, mkexpr(n4), mkU8(8))));
29580 // assign(n6, binop(Iop_Or32, mkexpr(n5), binop(Iop_Shr32, mkexpr(n5), mkU8(16))));
29585 // assign(n7, unop(Iop_Not32, mkexpr(n6)));
29597 // assign(n8,
29603 // assign(n9,
29609 // assign(n10,
29615 // assign(n11,
29619 // assign(n12,
