Lines Matching full:mkexpr
543 static IRExpr* mkexpr ( IRTemp tmp )
609 assign( *vOdd, binop(Iop_MullEven8Ux16, mkexpr(ones8x16), vIn) );
610 assign( *vEvn, binop(Iop_MullEven8Ux16, mkexpr(ones8x16),
627 assign( *vOdd, binop(Iop_MullEven8Sx16, mkexpr(ones8x16), vIn) );
628 assign( *vEvn, binop(Iop_MullEven8Sx16, mkexpr(ones8x16),
645 assign( *vOdd, binop(Iop_MullEven16Ux8, mkexpr(ones16x8), vIn) );
646 assign( *vEvn, binop(Iop_MullEven16Ux8, mkexpr(ones16x8),
663 assign( *vOdd, binop(Iop_MullEven16Sx8, mkexpr(ones16x8), vIn) );
664 assign( *vEvn, binop(Iop_MullEven16Sx8, mkexpr(ones16x8),
692 unop( Iop_64HIto32, mkexpr( hi64 ) ) ) ) );
695 unop( Iop_ReinterpI32asF32, unop( Iop_64to32, mkexpr( hi64 ) ) ) ) );
699 unop( Iop_64HIto32, mkexpr( lo64 ) ) ) ) );
702 unop( Iop_ReinterpI32asF32, unop( Iop_64to32, mkexpr( lo64 ) ) ) ) );
727 assign( *t3, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(hi64))) );
728 assign( *t2, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(hi64))) );
729 assign( *t1, unop(Iop_32Sto64, unop(Iop_64HIto32, mkexpr(lo64))) );
730 assign( *t0, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(lo64))) );
754 assign( *t3, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(hi64))) );
755 assign( *t2, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(hi64))) );
756 assign( *t1, unop(Iop_32Uto64, unop(Iop_64HIto32, mkexpr(lo64))) );
757 assign( *t0, unop(Iop_32Uto64, unop(Iop_64to32, mkexpr(lo64))) );
780 assign( *t3, unop(Iop_64HIto32, mkexpr(hi64)) );
781 assign( *t2, unop(Iop_64to32, mkexpr(hi64)) );
782 assign( *t1, unop(Iop_64HIto32, mkexpr(lo64)) );
783 assign( *t0, unop(Iop_64to32, mkexpr(lo64)) );
801 binop(Iop_CmpEQ32, mkexpr(hi32),
802 binop( Iop_Sar32, mkexpr(lo32), mkU8(31)))),
805 binop(Iop_Shr32, mkexpr(hi32), mkU8(31))),
807 mkexpr(lo32) );
823 unop(Iop_1Uto8, binop(Iop_CmpEQ32, mkexpr(hi32), mkU32(0))),
827 mkexpr(lo32) );
1157 stmt( IRStmt_Put( floatGuestRegOffset( archreg ), mkexpr( high ) ) );
1158 stmt( IRStmt_Put( floatGuestRegOffset( archreg + 1 ), mkexpr( low ) ) );
1373 mkexpr(old),
1374 mkexpr(mask[i])),
1376 binop(Iop_Shr32, mkexpr(old), mkU8(shift[i])),
1377 mkexpr(mask[i]))));
1406 binop( Iop_And64, mkexpr( old ), mkexpr( mask[i] ) ),
1408 binop( Iop_Shr64, mkexpr( old ), mkU8( shift[i] ) ),
1409 mkexpr( mask[i] ) ) ) );
1526 binop(Iop_And64, mkexpr(addr), mkU64(align-1)),
1537 binop(Iop_And32, mkexpr(addr), mkU32(align-1)),
1565 mkexpr(nia)
1572 mkexpr(nia)
1769 binop(Iop_OrV128, mkexpr(v0), mkexpr(v1)),
1770 binop(Iop_OrV128, mkexpr(v2), mkexpr(v3))))
1778 binop(Iop_AndV128, mkexpr(v0), mkexpr(v1)),
1779 binop(Iop_AndV128, mkexpr(v2), mkexpr(v3)))
1782 binop(Iop_Shl8, mkexpr(rOnes), mkU8(3)),
1783 binop(Iop_Shl8, mkexpr(rZeros), mkU8(1))) );
1785 putCR321( 6, binop(Iop_Shl8, mkexpr(rZeros), mkU8(1)) );
1934 unop(Iop_64HIto32, mkexpr(t64)),
1936 unop(Iop_64to32, mkexpr(t64)),
2545 return binop(Iop_And32, mkexpr(val), mkU32(mask));
2547 return mkexpr(val);
2777 mkexpr( x ), \
2784 binop( Iop_Shr32, mkexpr( src ), mkU8( 23 ) ),
2797 mkexpr( src ) ),
2802 binop( Iop_Shr64, mkexpr( src ), mkU8( 52 ) ),
2812 assign( frac_part, binop( Iop_And32, mkexpr(src), mkU32(0x007fffff)) );
2814 return mkAND1( Inf_exp, binop( Iop_CmpEQ32, mkexpr( frac_part ), mkU32( 0 ) ) );
2830 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
2831 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
2839 assign( sign_less_part, binop( Iop_And32, mkexpr( src ), mkU32( SIGN_MASK32 ) ) );
2840 return binop( Iop_CmpEQ32, mkexpr( sign_less_part ), mkU32( 0 ) );
2853 assign( sign_less_part, binop( Iop_And64, mkexpr( src ), mkU64( SIGN_MASK ) ) );
2854 hi32 = unop( Iop_64HIto32, mkexpr( sign_less_part ) );
2855 low32 = unop( Iop_64to32, mkexpr( sign_less_part ) );
2870 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
2871 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
2886 mkexpr( x ), \
2891 binop( Iop_Shr32, mkexpr( src ), mkU8( 23 ) ),
2914 binop( Iop_And64, mkexpr( intermediateResult ),
2924 mkexpr( signbit_32 ),
2931 mkexpr( intermediateResult ),
2935 unop( Iop_1Uto32, mkexpr( resultantSignbit ) ),
2957 binop( Iop_And32, mkexpr( intermediateResult ),
2967 mkexpr( signbit_32 ),
2974 mkexpr( intermediateResult ),
2977 unop( Iop_1Uto32, mkexpr( resultantSignbit ) ),
3017 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3020 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3026 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3029 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3043 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3055 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3064 binop(Iop_MullS64, mkexpr(rA),
3068 binop(Iop_MullS32, mkexpr(rA),
3077 mkexpr(rA)) );
3079 mkexpr(rD), mkexpr(rA), mkSzExtendS16(ty, uimm16),
3093 mkexpr(rA), mkexpr(rB) ) );
3096 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3105 mkexpr(rA), mkexpr(rB)) );
3107 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3111 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3122 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3124 mkexpr(rB), mkexpr(old_xer_ca))) );
3126 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3127 mkexpr(old_xer_ca) );
3130 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3149 assign( rD, binop( mkSzOp(ty, Iop_Add8), mkexpr(rA),
3151 min_one, mkexpr(old_xer_ca)) ));
3153 mkexpr(rD), mkexpr(rA), min_one,
3154 mkexpr(old_xer_ca) );
3157 mkexpr(rD), mkexpr(rA), min_one );
3175 mkexpr(rA), mkexpr(old_xer_ca)) );
3177 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0),
3178 mkexpr(old_xer_ca) );
3181 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0) );
3198 IRExpr* dividend = mk64lo32Sto64( mkexpr(rA) );
3199 IRExpr* divisor = mk64lo32Sto64( mkexpr(rB) );
3204 mkexpr(rD), dividend, divisor );
3207 assign( rD, binop(Iop_DivS32, mkexpr(rA), mkexpr(rB)) );
3210 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3229 IRExpr* dividend = mk64lo32Uto64( mkexpr(rA) );
3230 IRExpr* divisor = mk64lo32Uto64( mkexpr(rB) );
3235 mkexpr(rD), dividend, divisor );
3238 assign( rD, binop(Iop_DivU32, mkexpr(rA), mkexpr(rB)) );
3241 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3259 mk64lo32Sto64( mkexpr(rA) ),
3260 mk64lo32Sto64( mkexpr(rB) )),
3265 mkexpr(rA), mkexpr(rB))) );
3281 mk64lo32Uto64( mkexpr(rA) ),
3282 mk64lo32Uto64( mkexpr(rB) ) ),
3287 mkexpr(rA), mkexpr(rB))) );
3298 IRExpr *a = unop(Iop_64to32, mkexpr(rA) );
3299 IRExpr *b = unop(Iop_64to32, mkexpr(rB) );
3303 mkexpr(rD),
3309 mkexpr(rA), mkexpr(rB))) );
3312 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3327 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA) ),
3331 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3341 mkexpr(rB), mkexpr(rA)) );
3344 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3354 mkexpr(rB), mkexpr(rA)) );
3356 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3360 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3372 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA)),
3374 mkexpr(rB), mkexpr(old_xer_ca))) );
3376 mkexpr(rD), mkexpr(rA), mkexpr(rB),
3377 mkexpr(old_xer_ca) );
3380 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3400 unop( mkSzOp(ty, Iop_Not8), mkexpr(rA)),
3402 min_one, mkexpr(old_xer_ca))) );
3404 mkexpr(rD), mkexpr(rA), min_one,
3405 mkexpr(old_xer_ca) );
3408 mkexpr(rD), mkexpr(rA), min_one );
3427 mkexpr(rA)), mkexpr(old_xer_ca)) );
3429 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0),
3430 mkexpr(old_xer_ca) );
3433 mkexpr(rD), mkexpr(rA), mkSzImm(ty, 0) );
3449 mkexpr(rA), mkexpr(rB))) );
3462 mkexpr(rA), mkexpr(rB))) );
3469 assign( rD, binop(Iop_Mul64, mkexpr(rA), mkexpr(rB)) );
3472 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3480 assign( rD, binop(Iop_DivS64, mkexpr(rA), mkexpr(rB)) );
3483 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3495 assign( rD, binop(Iop_DivU64, mkexpr(rA), mkexpr(rB)) );
3498 mkexpr(rD), mkexpr(rA), mkexpr(rB) );
3518 dividend = unop( Iop_64to32, mkexpr( rA ) );
3519 divisor = unop( Iop_64to32, mkexpr( rB ) );
3521 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3523 dividend = mkexpr( rA );
3524 divisor = mkexpr( rB );
3526 assign( rD, mkexpr( res) );
3531 mkexpr(res), dividend, divisor );
3553 dividend = unop( Iop_64to32, mkexpr( rA ) );
3554 divisor = unop( Iop_64to32, mkexpr( rB ) );
3556 assign( rD, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( res ) ) );
3558 dividend = mkexpr( rA );
3559 divisor = mkexpr( rB );
3561 assign( rD, mkexpr( res) );
3566 mkexpr(res), dividend, divisor );
3584 assign( rD, binop(Iop_DivS64E, mkexpr(rA), mkexpr(rB)) );
3586 set_XER_OV_64( PPCG_FLAG_OP_DIVDE, mkexpr( rD ),
3587 mkexpr( rA ), mkexpr( rB ) );
3596 assign( rD, binop(Iop_DivU64E, mkexpr(rA), mkexpr(rB)) );
3598 set_XER_OV_64( PPCG_FLAG_OP_DIVDEU, mkexpr( rD ),
3599 mkexpr( rA ), mkexpr( rB ) );
3614 putIReg( rD_addr, mkexpr(rD) );
3617 set_CR0( mkexpr(rD) );
3771 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
3779 assign( rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
3787 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
3793 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
3799 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
3805 assign( rA, binop( mkSzOp(ty, Iop_Xor8), mkexpr(rS),
3818 mkexpr(rS), mkexpr(rB)));
3824 assign(rA, binop( mkSzOp(ty, Iop_And8), mkexpr(rS),
3826 mkexpr(rB))));
3839 mkexpr(rS)) : mkexpr(rS);
3858 mkexpr(rS), mkexpr(rB))) );
3869 assign( rA, unop(Iop_8Sto64, unop(Iop_64to8, mkexpr(rS))) );
3871 assign( rA, unop(Iop_8Sto32, unop(Iop_32to8, mkexpr(rS))) );
3883 unop(Iop_64to16, mkexpr(rS))) );
3886 unop(Iop_32to16, mkexpr(rS))) );
3894 mkexpr(rS), mkexpr(rB))) );
3902 mkexpr(rS), mkexpr(rB))) );
3908 assign( rA, mkexpr(rS) );
3913 mkexpr(rS), mkexpr(rB)) );
3920 assign( rA, binop( mkSzOp(ty, Iop_Or8), mkexpr(rS),
3921 unop(mkSzOp(ty, Iop_Not8), mkexpr(rB))));
3928 mkexpr(rS), mkexpr(rB)) );
3939 assign(rA, unop(Iop_32Sto64, unop(Iop_64to32, mkexpr(rS))));
3950 irx = binop(Iop_CmpNE64, mkexpr(rS), mkU64(0));
3953 unop(Iop_Clz64, mkexpr(rS)) ));
3963 binop( Iop_64HLtoV128, mkU64(0), mkexpr(rS) ),
3964 binop( Iop_64HLtoV128, mkU64(0), mkexpr(rB) )
3969 unop( Iop_32UtoV128, mkexpr(rS) ),
3970 unop( Iop_32UtoV128, mkexpr(rB) )
3980 assign( rA, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
3982 assign( rA, unop( Iop_64to32, unop( Iop_ReinterpF64asI64, mkexpr(frB))) );
3984 putIReg( rS_addr, mkexpr(rA));
3993 assign( frA, unop( Iop_ReinterpI64asF64, mkexpr(rB)) );
3995 assign( frA, unop( Iop_ReinterpI64asF64, unop( Iop_32Uto64, mkexpr(rB))) );
3997 putFReg( rS_addr, mkexpr(frA));
4004 putIReg( rA_addr, mkexpr(result) );
4014 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4015 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4018 putIReg( rA_addr, binop(Iop_32HLto64, mkexpr(resultHi), mkexpr(resultLo)));
4021 putIReg( rA_addr, mkexpr(result) );
4033 assign(argLo, unop(Iop_64to32, mkexpr(rS)));
4034 assign(argHi, unop(Iop_64HIto32, mkexpr(rS)));
4037 putIReg( rA_addr, binop(Iop_32HLto64, mkexpr(resultHi),
4038 mkexpr(resultLo)));
4041 putIReg( rA_addr, mkexpr(result) );
4056 IRExpr * rS_expr = mkexpr(rS);
4069 binop( Iop_CmpLT64U, mkexpr( idx_tmp ), mkU64( 64 ) ) );
4073 mkexpr(idx_LT64) ),
4074 unop( Iop_64to8, mkexpr( idx_tmp ) ) ) );
4081 unop( Iop_32Uto64, unop( Iop_1Uto32, mkexpr(idx_LT64 ) ) ) );
4084 mkexpr( idx_LT64_ity64 ),
4089 mkexpr( rB ),
4090 mkexpr( idx ) ) ),
4095 mkexpr( perm_bit ),
4114 putIReg( rA_addr, mkexpr(rA) );
4117 set_CR0( mkexpr(rA) );
4168 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4169 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4171 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS1))),
4172 mkexpr(iTot1)) );
4173 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4175 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS2))),
4176 mkexpr(iTot2)) );
4177 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4179 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS3))),
4180 mkexpr(iTot3)) );
4182 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4184 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))),
4185 mkexpr(iTot4)) );
4186 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4188 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS5))),
4189 mkexpr(iTot5)) );
4190 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4192 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS6))),
4193 mkexpr(iTot6)) );
4194 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)) );
4196 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS7))),
4197 mkexpr(iTot7)) );
4199 binop(Iop_And32, mkexpr(iTot8), mkU32(1))) );
4201 assign( rA, mkexpr(iTot4) );
4205 assign( iTot1, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS))) );
4206 assign( rS1, binop(shr_op, mkexpr(rS), mkU8(8)) );
4208 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS1))),
4209 mkexpr(iTot1)) );
4210 assign( rS2, binop(shr_op, mkexpr(rS1), mkU8(8)) );
4212 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS2))),
4213 mkexpr(iTot2)) );
4214 assign( rS3, binop(shr_op, mkexpr(rS2), mkU8(8)) );
4216 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS3))),
4217 mkexpr(iTot3)) );
4218 assign( iLo, unop(Iop_1Uto32, unop(Iop_32to1, mkexpr(iTot4) )) );
4221 assign( rS4, binop(shr_op, mkexpr(rS3), mkU8(8)) );
4222 assign( iTot5, unop(Iop_1Uto32, unop(to_bit, mkexpr(rS4))) );
4223 assign( rS5, binop(shr_op, mkexpr(rS4), mkU8(8)) );
4225 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS5))),
4226 mkexpr(iTot5)) );
4227 assign( rS6, binop(shr_op, mkexpr(rS5), mkU8(8)) );
4229 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS6))),
4230 mkexpr(iTot6)) );
4231 assign( rS7, binop(shr_op, mkexpr(rS6), mkU8(8)));
4233 unop(Iop_1Uto32, unop(to_bit, mkexpr(rS7))),
4234 mkexpr(iTot7)) );
4235 assign( iHi, binop(Iop_And32, mkU32(1), mkexpr(iTot8)) ),
4236 assign( rA, binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo)) );
4238 assign( rA, binop(Iop_Or32, mkU32(0), mkexpr(iLo)) );
4245 putIReg( rA_addr, mkexpr(rA) );
4290 r = ROTL( unop(Iop_64to32, mkexpr(rS) ), mkU8(sh_imm) );
4296 binop(Iop_And64, mkexpr(rot), mkU64(mask64)),
4302 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4324 r = ROTL( unop(Iop_64to32, mkexpr(rS) ), mkU8(sh_imm) );
4328 assign( rot, binop(Iop_Or64, mkexpr(rTmp),
4329 binop(Iop_Shl64, mkexpr(rTmp), mkU8(32))) );
4330 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4338 assign( rA, binop(Iop_Shl32, mkexpr(rS), mkU8(sh_imm)) );
4345 assign( rA, binop(Iop_Shr32, mkexpr(rS), mkU8(MaskBeg)) );
4354 ROTL(mkexpr(rS), mkU8(sh_imm)),
4372 r = ROTL( unop(Iop_64to32, mkexpr(rS)),
4373 unop(Iop_64to8, mkexpr(rB)) );
4376 assign( rA, binop(Iop_And64, mkexpr(rot), mkU64(mask64)) );
4382 ROTL(mkexpr(rS),
4383 unop(Iop_32to8, mkexpr(rB))),
4400 r = ROTL( mkexpr(rS), unop(Iop_64to8, mkexpr(rB)) );
4421 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4440 assign( rA, binop(Iop_Shr64, mkexpr(rS), mkU8(msk_imm)) );
4444 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4457 assign( rA, binop(Iop_Shl64, mkexpr(rS), mkU8(sh_imm)) );
4461 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4471 r = ROTL(mkexpr(rS), mkU8(sh_imm));
4477 mkexpr(rA_orig))) );
4492 putIReg( rA_addr, mkexpr(rA) );
4495 set_CR0( mkexpr(rA) );
4536 val = loadBE(Ity_I8, mkexpr(EA));
4546 val = loadBE(Ity_I8, mkexpr(EA));
4548 putIReg( rA_addr, mkexpr(EA) );
4553 val = loadBE(Ity_I16, mkexpr(EA));
4563 val = loadBE(Ity_I16, mkexpr(EA));
4565 putIReg( rA_addr, mkexpr(EA) );
4570 val = loadBE(Ity_I16, mkexpr(EA));
4580 val = loadBE(Ity_I16, mkexpr(EA));
4582 putIReg( rA_addr, mkexpr(EA) );
4587 val = loadBE(Ity_I32, mkexpr(EA));
4597 val = loadBE(Ity_I32, mkexpr(EA));
4599 putIReg( rA_addr, mkexpr(EA) );
4616 val = loadBE(Ity_I8, mkexpr(EA));
4618 putIReg( rA_addr, mkexpr(EA) );
4623 val = loadBE(Ity_I8, mkexpr(EA));
4633 val = loadBE(Ity_I16, mkexpr(EA));
4635 putIReg( rA_addr, mkexpr(EA) );
4640 val = loadBE(Ity_I16, mkexpr(EA));
4650 val = loadBE(Ity_I16, mkexpr(EA));
4652 putIReg( rA_addr, mkexpr(EA) );
4657 val = loadBE(Ity_I16, mkexpr(EA));
4667 val = loadBE(Ity_I32, mkexpr(EA));
4669 putIReg( rA_addr, mkexpr(EA) );
4674 val = loadBE(Ity_I32, mkexpr(EA));
4686 mkexpr(EA)) );
4687 putIReg( rA_addr, mkexpr(EA) );
4692 putIReg( rD_addr, loadBE(Ity_I64, mkexpr(EA)) );
4702 unop(Iop_32Sto64, loadBE(Ity_I32, mkexpr(EA))) );
4703 putIReg( rA_addr, mkexpr(EA) );
4709 unop(Iop_32Sto64, loadBE(Ity_I32, mkexpr(EA))) );
4724 putIReg( rD_addr, loadBE(Ity_I64, mkexpr(EA)) );
4733 putIReg( rD_addr, loadBE(Ity_I64, mkexpr(EA)) );
4734 putIReg( rA_addr, mkexpr(EA) );
4740 unop(Iop_32Sto64, loadBE(Ity_I32, mkexpr(EA))) );
4797 storeBE( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
4806 putIReg( rA_addr, mkexpr(EA) );
4807 storeBE( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
4812 storeBE( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
4821 putIReg( rA_addr, mkexpr(EA) );
4822 storeBE( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
4827 storeBE( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
4836 putIReg( rA_addr, mkexpr(EA) );
4837 storeBE( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
4854 putIReg( rA_addr, mkexpr(EA) );
4855 storeBE( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
4860 storeBE( mkexpr(EA), mkNarrowTo8(ty, mkexpr(rS)) );
4869 putIReg( rA_addr, mkexpr(EA) );
4870 storeBE( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
4875 storeBE( mkexpr(EA), mkNarrowTo16(ty, mkexpr(rS)) );
4884 putIReg( rA_addr, mkexpr(EA) );
4885 storeBE( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
4890 storeBE( mkexpr(EA), mkNarrowTo32(ty, mkexpr(rS)) );
4901 putIReg( rA_addr, mkexpr(EA) );
4902 storeBE( mkexpr(EA), mkexpr(rS) );
4907 storeBE( mkexpr(EA), mkexpr(rS) );
4922 storeBE( mkexpr(EA), mkexpr(rS) );
4927 putIReg( rA_addr, mkexpr(EA) );
4928 storeBE( mkexpr(EA), mkexpr(rS) );
4975 irx_addr = binop(Iop_Add32, mkexpr(EA), mkU32(ea_off));
4985 irx_addr = binop(Iop_Add32, mkexpr(EA), mkU32(ea_off));
5010 IRExpr* e_nbytes = mkexpr(tNBytes);
5011 IRExpr* e_EA = mkexpr(EA);
5061 IRExpr* e_nbytes = mkexpr(tNBytes);
5062 IRExpr* e_EA = mkexpr(EA);
5124 loadBE(Ity_I32, mkexpr(t_EA)) );
5127 binop(Iop_Add32, mkexpr(t_EA), mkU32(4))) );
5159 storeBE( mkexpr(t_EA),
5161 storeBE( binop(Iop_Add32, mkexpr(t_EA), mkU32(4)),
5218 return mkexpr(ok);
5243 assign( res, mkexpr(cr_bi) );
5248 assign( res, binop(Iop_Xor32, mkexpr(cr_bi),
5252 return mkexpr(res);
5350 binop(Iop_And32, mkexpr(cond_ok), mkexpr(ctr_ok)) );
5362 binop(Iop_CmpNE32, mkexpr(do_branch), mkU32(0)),
5397 binop(Iop_CmpEQ32, mkexpr(cond_ok), mkU32(0)),
5407 putGST( PPC_GST_CIA, mkexpr(lr_old) );
5429 binop(Iop_And32, mkexpr(cond_ok), mkexpr(ctr_ok)) );
5437 binop(Iop_CmpEQ32, mkexpr(do_branch), mkU32(0)),
5450 putGST( PPC_GST_CIA, mkexpr(lr_old) );
5512 assign( crbD, binop(Iop_And32, mkexpr(crbA), mkexpr(crbB)) );
5517 mkexpr(crbA),
5518 unop(Iop_Not32, mkexpr(crbB))) );
5523 binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB))) );
5528 binop(Iop_And32, mkexpr(crbA), mkexpr(crbB))) );
5533 binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB))) );
5537 assign( crbD, binop(Iop_Or32, mkexpr(crbA), mkexpr(crbB)) );
5542 mkexpr(crbA),
5543 unop(Iop_Not32, mkexpr(crbB))) );
5547 assign( crbD, binop(Iop_Xor32, mkexpr(crbA), mkexpr(crbB)) );
5554 putCRbit( crbD_addr, mkexpr(crbD) );
5623 argLe = mkexpr(argL);
5624 argRe = mkexpr(argR);
5865 stmt( IRStmt_LLSC(Iend_BE, res, mkexpr(EA), NULL/*this is a load*/) );
5867 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(res), False) );
5891 stmt( IRStmt_LLSC(Iend_BE, resSC, mkexpr(EA), mkexpr(rS)) );
5895 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
5958 stmt( IRStmt_LLSC(Iend_BE, res, mkexpr(EA), NULL/*this is a load*/) );
5960 putIReg( rD_addr, mkexpr(res) );
5984 stmt( IRStmt_LLSC(Iend_BE, resSC, mkexpr(EA), mkexpr(rS)) );
5988 putCR321(0, binop(Iop_Shl8, unop(Iop_1Uto8, mkexpr(resSC)), mkU8(1)));
6039 assign( rS_lo32, mkNarrowTo32(ty, mkexpr(rS)) );
6040 assign( rB_lo32, mkNarrowTo32(ty, mkexpr(rB)) );
6056 mkexpr(rS_lo32),
6059 mkexpr(rB_lo32), mkU32(31)))),
6062 binop(Iop_Shl32, mkexpr(rB_lo32), mkU8(26)),
6078 mkexpr(rB_lo32)) );
6082 mkexpr(sh_amt)) ));
6084 mkexpr(rS_lo32),
6086 IRExpr_Mux0X( mkexpr(outofrange),
6087 mkexpr(sh_amt),
6092 mkexpr(rA),
6093 mkWidenFrom32(ty, mkexpr(rS_lo32), True),
6094 mkWidenFrom32(ty, mkexpr(sh_amt), True ),
6109 assign( rA, binop(Iop_Sar32, mkexpr(rS_lo32),
6114 mkexpr(rA),
6115 mkWidenFrom32(ty, mkexpr(rS_lo32), /* Syned */True),
6133 mkexpr(rS_lo32),
6135 binop(Iop_And32, mkexpr(rB_lo32),
6139 binop(Iop_Shl32, mkexpr(rB_lo32),
6160 mkexpr(rS),
6162 binop(Iop_And64, mkexpr(rB), mkU64(63)))),
6165 binop(Iop_Shl64, mkexpr(rB), mkU8(57)),
6177 assign( sh_amt, binop(Iop_And64, mkU64(0x7F), mkexpr(rB)) );
6181 mkexpr(sh_amt)) ));
6184 mkexpr(rS),
6186 IRExpr_Mux0X( mkexpr(outofrange),
6187 mkexpr(sh_amt),
6191 mkexpr(rA), mkexpr(rS), mkexpr(sh_amt),
6204 mkexpr(rA),
6223 mkexpr(rS),
6225 binop(Iop_And64, mkexpr(rB), mkU64(63)))),
6228 binop(Iop_Shl64, mkexpr(rB), mkU8(57)),
6241 putIReg( rA_addr, mkexpr(rA) );
6244 set_CR0( mkexpr(rA) );
6260 binop(Iop_Shl32, mkexpr(t), mkU8(24)),
6262 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t), mkU8(8)),
6265 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(8)),
6267 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(24)),
6279 binop(Iop_And32, binop(Iop_Shl32, mkexpr(t), mkU8(8)),
6281 binop(Iop_And32, binop(Iop_Shr32, mkexpr(t), mkU8(8)),
6313 assign( w1, unop(Iop_16Uto32, loadBE(Ity_I16, mkexpr(EA))) );
6315 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(w2),
6321 assign( w1, loadBE(Ity_I32, mkexpr(EA)) );
6323 putIReg( rD_addr, mkWidenFrom32(ty, mkexpr(w2),
6333 assign( w1, loadBE( Ity_I32, mkexpr( EA ) ) );
6335 nextAddr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
6339 putIReg( rD_addr, binop( Iop_32HLto64, mkexpr( w4 ), mkexpr( w2 ) ) );
6346 storeBE( mkexpr(EA), unop(Iop_32to16, gen_byterev16(w1)) );
6352 storeBE( mkexpr(EA), gen_byterev32(w1) );
6362 assign(lo, unop(Iop_64HIto32, mkexpr(rS)));
6363 assign(hi, unop(Iop_64to32, mkexpr(rS)));
6364 storeBE( mkexpr( EA ),
6502 mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
6523 mkWidenFrom32(ty, mkexpr(val), False/*unsigned*/) );
6550 mkWidenFrom32(ty, unop(Iop_64HIto32, mkexpr(val)),
6555 putIReg( rD_addr, (mode64) ? mkexpr(val) :
6556 unop(Iop_64to32, mkexpr(val)) );
6592 mkNarrowTo32(ty, mkexpr(rS)),
6603 putGST( PPC_GST_XER, mkNarrowTo32(ty, mkexpr(rS)) );
6607 putGST( PPC_GST_LR, mkexpr(rS) );
6611 putGST( PPC_GST_CTR, mkexpr(rS) );
6615 putGST( PPC_GST_VRSAVE, mkNarrowTo32(ty, mkexpr(rS)) );
6729 mkexpr(EA),
6733 irx_addr = binop( Iop_Add64, mkexpr(addr), mkU64(i*8) );
6739 mkexpr(EA),
6743 irx_addr = binop( Iop_Add32, mkexpr(addr), mkU32(i*4) );
6761 mkexpr(EA),
6763 putGST( PPC_GST_TISTART, mkexpr(addr) );
6807 mkexpr(rm_PPC32),
6809 binop(Iop_Shl32, mkexpr(rm_PPC32), mkU8(1)),
6835 mkexpr( rm_PPC32 ),
6837 binop( Iop_Shl32, mkexpr( rm_PPC32 ), mkU8( 1 ) ),
6886 mkexpr( frac_mask ) ),
6898 mkexpr( exp_zero ),
6899 mkexpr( frac_not_zero ) ) );
6964 unop(Iop_F32toF64, loadBE(Ity_F32, mkexpr(EA))) );
6973 unop(Iop_F32toF64, loadBE(Ity_F32, mkexpr(EA))) );
6974 putIReg( rA_addr, mkexpr(EA) );
6980 putFReg( frD_addr, loadBE(Ity_F64, mkexpr(EA)) );
6988 putFReg( frD_addr, loadBE(Ity_F64, mkexpr(EA)) );
6989 putIReg( rA_addr, mkexpr(EA) );
7003 loadBE(Ity_F32, mkexpr(EA))) );
7012 unop(Iop_F32toF64, loadBE(Ity_F32, mkexpr(EA))) );
7013 putIReg( rA_addr, mkexpr(EA) );
7019 putFReg( frD_addr, loadBE(Ity_F64, mkexpr(EA)) );
7027 putFReg( frD_addr, loadBE(Ity_F64, mkexpr(EA)) );
7028 putIReg( rA_addr, mkexpr(EA) );
7034 assign( iLo, loadBE(Ity_I32, mkexpr(EA)) );
7037 binop(Iop_Shr32, mkexpr(iLo), mkU8(31))) );
7039 binop(Iop_32HLto64, mkexpr(iHi), mkexpr(iLo))) );
7047 assign( iLo, loadBE(Ity_I32, mkexpr(EA)) );
7048 assign( dw, binop( Iop_32HLto64, mkU32( 0 ), mkexpr( iLo ) ) );
7049 putFReg( frD_addr, unop( Iop_ReinterpI64asF64, mkexpr( dw ) ) );
7106 storeBE( mkexpr(EA),
7107 unop(Iop_TruncF64asF32, mkexpr(frS)) );
7116 storeBE( mkexpr(EA),
7117 unop(Iop_TruncF64asF32, mkexpr(frS)) );
7118 putIReg( rA_addr, mkexpr(EA) );
7124 storeBE( mkexpr(EA), mkexpr(frS) );
7132 storeBE( mkexpr(EA), mkexpr(frS) );
7133 putIReg( rA_addr, mkexpr(EA) );
7146 storeBE( mkexpr(EA),
7147 unop(Iop_TruncF64asF32, mkexpr(frS)) );
7156 storeBE( mkexpr(EA),
7157 unop(Iop_TruncF64asF32, mkexpr(frS)) );
7158 putIReg( rA_addr, mkexpr(EA) );
7164 storeBE( mkexpr(EA), mkexpr(frS) );
7172 storeBE( mkexpr(EA), mkexpr(frS) );
7173 putIReg( rA_addr, mkexpr(EA) );
7180 storeBE( mkexpr(EA),
7181 unop(Iop_64to32, unop(Iop_ReinterpF64asI64, mkexpr(frS))) );
7243 rm, mkexpr(frA), mkexpr(frB) ));
7252 rm, mkexpr(frA), mkexpr(frB) ));
7261 rm, mkexpr(frA), mkexpr(frB) ));
7272 assign( frD, binop( Iop_SqrtF64, rm, mkexpr(frB) ));
7285 ieee_one, mkexpr(frB) ));
7295 rm, mkexpr(frA), mkexpr(frC) ));
7305 assign( frD, unop(Iop_Est5FRSqrt, mkexpr(frB)) );
7321 assign( frD, triop(Iop_DivF64, rm, mkexpr(frA), mkexpr(frB)) );
7329 assign( frD, triop(Iop_SubF64, rm, mkexpr(frA), mkexpr(frB)) );
7337 assign( frD, triop(Iop_AddF64, rm, mkexpr(frA), mkexpr(frB)) );
7346 assign( frD, binop(Iop_SqrtF64, rm, mkexpr(frB)) );
7359 assign( cc, binop(Iop_CmpF64, mkexpr(frA),
7361 assign( cc_b0, binop(Iop_And32, mkexpr(cc), mkU32(1)) );
7368 binop(Iop_CmpEQ32, mkexpr(cc_b0), mkU32(0))),
7369 mkexpr(frB),
7370 mkexpr(frC) ));
7389 ieee_one, mkexpr(frB) ));
7398 assign( frD, triop(Iop_MulF64, rm, mkexpr(frA), mkexpr(frC)) );
7407 assign( frD, unop(Iop_Est5FRSqrt, mkexpr(frB)) );
7421 putFReg( frD_addr, mkexpr(frD) );
7477 rm = mkexpr(rmt);
7498 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
7505 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
7515 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
7520 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
7523 assign( nan_mask, Check_NaN( mkexpr( tmp ),
7525 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
7526 mkexpr( nan_mask ) ) );
7527 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
7542 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
7549 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
7559 mkexpr(frA), mkexpr(frC), mkexpr(frB) ) );
7564 mkexpr(frA), mkexpr(frC), mkexpr(frB) ));
7567 assign( nan_mask, Check_NaN( mkexpr( tmp ),
7569 assign( sign_tmp, Complement_non_NaN( mkexpr( tmp ),
7570 mkexpr( nan_mask ) ) );
7571 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr( sign_tmp ) ) );
7585 putFReg( frD_addr, mkexpr(frD) );
7627 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
7640 eb_LTE = binop( Iop_CmpLE32S, mkexpr( e_b ), mkU32( test_value ) );
7644 sp ? mkexpr( frB_Int ) : unop( Iop_64HIto32, mkexpr( frB_Int ) ),
7664 assign( frac_part, binop( Iop_And32, mkexpr(frB_Int), mkU32(0x007fffff)) );
7666 = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ), mkU32( 0 ) ),
7667 binop( Iop_CmpNE32, mkexpr( frac_part ), mkU32( 0 ) ) );
7673 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
7674 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
7678 = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ), mkU32( 0 ) ),
7684 fe_flag = mkOR1( mkexpr( frbZero_tmp ),
7686 mkOR1( mkexpr( frbInf_tmp ),
7691 fg_flag = mkOR1( mkexpr( frbZero_tmp ),
7692 mkOR1( mkexpr( frbInf_tmp ), frbDenorm ) );
7753 assign(e_a, binop( Iop_Sub32, mkexpr(frA_exp_shR), mkU32( bias ) ));
7754 assign(e_b, binop( Iop_Sub32, mkexpr(frB_exp_shR), mkU32( bias ) ));
7793 eb_LTE = binop(Iop_CmpLE32S, mkexpr(e_b), mkU32(test_value));
7802 eb_GTE = binop(Iop_CmpLT32S, mkU32(test_value), mkexpr(e_b));
7809 ea_eb_GTE = mkAND1( mkexpr( fraNotZero_tmp ),
7811 binop( Iop_Sub32, mkexpr( e_a ),
7812 mkexpr( e_b ) ) ) );
7820 ea_eb_LTE = mkAND1( mkexpr( fraNotZero_tmp ),
7823 mkexpr( e_a ),
7824 mkexpr( e_b ) ),
7834 ea_LTE = mkAND1( mkexpr( fraNotZero_tmp ), binop( Iop_CmpLE32S,
7835 mkexpr( e_a ),
7865 hi32 = unop( Iop_64HIto32, mkexpr( frac_part ) );
7866 low32 = unop( Iop_64to32, mkexpr( frac_part ) );
7870 frbDenorm = mkAND1( binop( Iop_CmpEQ32, mkexpr( frB_exp_shR ),
7880 mkexpr( fraInf_tmp ),
7882 mkexpr( frbZero_tmp ),
7886 mkexpr( frbInf_tmp ),
7895 fg_flag = mkOR1( mkexpr( fraInf_tmp ), mkOR1( mkexpr( frbZero_tmp ),
7896 mkOR1( mkexpr( frbInf_tmp ),
7917 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
7918 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) );
7971 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
7972 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) ) );
7973 putGST_field( PPC_GST_CR, mkexpr(flags), crfD );
8013 assign( ccIR, binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)) );
8040 binop(Iop_Shr32, mkexpr(ccIR), mkU8(5))
8048 mkexpr(ccIR),
8049 binop(Iop_Shr32, mkexpr(ccIR), mkU8(6))
8058 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), crfD );
8061 putGST_field( PPC_GST_FPSCR, mkexpr(ccPPC32), 4 );
8127 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8129 mkexpr( r_tmp64 ) ) ) );
8134 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8135 assign( frD, unop( Iop_F32toF64, binop( Iop_I64UtoF32, rm, mkexpr( r_tmp64 ) ) ) );
8144 assign( frD, binop( Iop_RoundF64toF32, rm, mkexpr(frB) ));
8150 binop(Iop_F64toI32S, rm, mkexpr(frB)) );
8152 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8160 binop(Iop_F64toI32S, mkU32(Irrm_ZERO), mkexpr(frB) ));
8162 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8173 mkexpr( frB ) ) );
8175 unop( Iop_32Uto64, mkexpr(r_tmp32))));
8184 binop(Iop_F64toI64S, rm, mkexpr(frB)) );
8185 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8193 binop(Iop_F64toI64S, mkU32(Irrm_ZERO), mkexpr(frB)) );
8194 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8204 binop(Iop_F64toI64U, opc2 == 0x3AE ? rm : mkU32(Irrm_ZERO), mkexpr(frB)) );
8205 assign( frD, unop( Iop_ReinterpI64asF64, mkexpr(r_tmp64)) );
8212 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8214 binop(Iop_I64StoF64, rm, mkexpr(r_tmp64)) );
8219 assign( r_tmp64, unop( Iop_ReinterpF64asI64, mkexpr(frB)) );
8220 assign( frD, binop( Iop_I64UtoF64, rm, mkexpr( r_tmp64 ) ) );
8228 binop(Iop_F64toI64S, mkU32(Irrm_NEAREST), mkexpr(frB)) );
8233 binop(Iop_F64toI64S, mkU32(Irrm_ZERO), mkexpr(frB)) );
8238 binop(Iop_F64toI64S, mkU32(Irrm_PosINF), mkexpr(frB)) );
8243 binop(Iop_F64toI64S, mkU32(Irrm_NegINF), mkexpr(frB)) );
8255 unop(Iop_AbsF64, mkexpr(frB)))),
8260 mkexpr(frB))), mkU8(31))),
8261 binop(Iop_I64StoF64, mkU32(0), mkexpr(r_tmp64) ),
8265 mkexpr(r_tmp64)) )) ),
8266 mkexpr(frB)));
8274 putFReg( frD_addr, mkexpr(frD) );
8352 assign( EA_lo, binop(Iop_Add64, mkexpr(EA_hi), mkU64(8)) );
8354 assign( EA_lo, binop(Iop_Add32, mkexpr(EA_hi), mkU32(8)) );
8360 putFReg( frT_hi_addr, loadBE(Ity_F64, mkexpr(EA_hi)) );
8361 putFReg( frT_lo_addr, loadBE(Ity_F64, mkexpr(EA_lo)) );
8363 storeBE( mkexpr(EA_hi), mkexpr(frT_hi) );
8364 storeBE( mkexpr(EA_lo), mkexpr(frT_lo) );
8411 mkexpr(frA))),
8414 assign( itmpB, unop(Iop_ReinterpF64asI64, mkexpr(frB)) );
8420 mkexpr(itmpB)), /* frB's high 32 bits */
8422 mkexpr(signA)) );
8427 mkexpr(hiD),
8429 mkexpr(itmpB)))) ); /* frB's low 32 bits */
8434 assign( frD, unop( Iop_NegF64, mkexpr(frB) ));
8439 assign( frD, mkexpr(frB) );
8444 assign( frD, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr(frB) )));
8449 assign( frD, unop( Iop_AbsF64, mkexpr(frB) ));
8457 putFReg( frD_addr, mkexpr(frD) );
8521 putGST_field( PPC_GST_CR, mkexpr(tmp), crfD );
8635 assign( rB_64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
8636 putGST_masked( PPC_GST_FPSCR, mkexpr( rB_64 ), mask );
8679 #define NOT(x) unop( Iop_1Uto32, unop( Iop_Not1, unop( Iop_32to1, mkexpr( x ) ) ) )
8737 mkexpr( lmexp_00_mask ),
8740 mkexpr( lmexp_01_mask ),
8742 binop( Iop_And32, mkexpr( lmexp_10_mask ), mkU32( 28 ) ) ) );
8747 mkexpr( lmexp_00_mask ),
8750 mkexpr( lmexp_01_mask ),
8752 binop( Iop_And32, mkexpr( lmexp_10_mask ), mkU32( 29 ) ) ) );
8758 mkexpr( lmd_07_mask ),
8759 mkexpr( lmd_07_val ) ),
8761 mkexpr( lmd_8_mask ),
8762 mkexpr( lmd_8_val ) ) ),
8763 binop( Iop_And32, mkexpr( lmd_9_mask ), mkexpr( lmd_9_val ) ) );
8832 OR( OR3 ( AND( mkexpr( lmd_07_mask ), mkexpr( lmd_07_val ) ),
8833 AND( mkexpr( lmd_8_00_mask ), mkexpr( lmd_8_val ) ),
8834 AND( mkexpr( lmd_8_01_mask ), mkexpr( lmd_8_val ) )),
8835 OR4( AND( mkexpr( lmd_8_10_mask ), mkexpr( lmd_8_val ) ),
8836 mkexpr( lmd_9_00_mask ), mkexpr( lmd_9_val ) ),
8837 AND( mkexpr( lmd_9_01_mask ), mkexpr( lmd_9_val ) ),
8838 AND( mkexpr( lmd_9_10_mask ), mkexpr( lmd_9_val ) )
8983 return unop( Iop_Not32, mkexpr( valid ) );
9063 assign( tmplow60, unop( Iop_DPBtoBCD, mkexpr( low_50 ) ) );
9064 assign( *low_60_u, unop( Iop_64HIto32, mkexpr( tmplow60 ) ) );
9065 assign( *low_60_l, unop( Iop_64to32, mkexpr( tmplow60 ) ) );
9092 assign( tmpmid60, unop( Iop_DPBtoBCD, mkexpr( mid_50 ) ) );
9093 assign( *mid_60_u, unop( Iop_64HIto32, mkexpr( tmpmid60 ) ) );
9094 assign( *mid_60_l, unop( Iop_64to32, mkexpr( tmpmid60 ) ) );
9109 assign( tmptop12, unop( Iop_DPBtoBCD, mkexpr( top_10 ) ) );
9110 assign( top_12_u, unop( Iop_64HIto32, mkexpr( tmptop12 ) ) );
9111 assign( *top_12_l, unop( Iop_64to32, mkexpr( tmptop12 ) ) );
9132 mkexpr( cnt[i-1] ),
9142 mkexpr( flag[i - 1] ),
9155 mkexpr( flag[i - 1] ) ) );
9173 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
9176 mkexpr( num_lmd ),
9177 mkexpr( lmd_flag ),
9183 mkexpr( num_upper ),
9184 mkexpr( upper_flag ),
9189 return mkexpr( num_low );
9213 assign( lmd_flag, unop( Iop_Not8, mkexpr( num_lmd ) ) );
9216 mkexpr( num_lmd ),
9217 mkexpr( lmd_flag ),
9223 mkexpr( num_top ),
9224 mkexpr( top_flag ),
9232 mkexpr( num_mid_u ),
9233 mkexpr( mid_u_flag ),
9239 mkexpr( num_mid_l ),
9240 mkexpr( mid_l_flag ),
9248 mkexpr( num_low_u ),
9249 mkexpr( low_u_flag ),
9254 return mkexpr( num_low_l );
9271 mkexpr( gfield0to5 ),
9275 mkexpr( gfield0to5 ),
9322 assign( frS, triop( Iop_AddD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9327 assign( frS, triop( Iop_SubD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9332 assign( frS, triop( Iop_MulD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9337 assign( frS, triop( Iop_DivD64, round, mkexpr( frA ), mkexpr( frB ) ) );
9341 putDReg( frS_addr, mkexpr( frS ) );
9380 assign( frS, triop( Iop_AddD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9385 assign( frS, triop( Iop_SubD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9390 assign( frS, triop( Iop_MulD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9395 assign( frS, triop( Iop_DivD128, round, mkexpr( frA ), mkexpr( frB ) ) );
9399 putDReg_pair( frS_addr, mkexpr( frS ) );
9427 assign( frS, binop( Iop_ShlD64, mkexpr( frA ), mkU8( shift_val ) ) );
9432 assign( frS, binop( Iop_ShrD64, mkexpr( frA ), mkU8( shift_val ) ) );
9436 putDReg( frS_addr, mkexpr( frS ) );
9464 assign( frS, binop( Iop_ShlD128, mkexpr( frA ), mkU8( shift_val ) ) );
9469 assign( frS, binop( Iop_ShrD128, mkexpr( frA ), mkU8( shift_val ) ) );
9473 putDReg_pair( frS_addr, mkexpr( frS ) );
9502 assign( frS, unop( Iop_D32toD64, mkexpr( frB ) ) );
9503 putDReg( frS_addr, mkexpr( frS ) );
9511 assign( frS, binop( Iop_D64toD32, round, mkexpr( frB ) ) );
9512 putDReg( frS_addr, mkexpr( frS ) );
9520 assign( frS, binop( Iop_D64toI64S, round, mkexpr( frB ) ) );
9521 putDReg( frS_addr, mkexpr( frS ) );
9529 assign( frS, binop( Iop_I64StoD64, round, mkexpr( frB ) ) );
9530 putDReg( frS_addr, mkexpr( frS ) );
9560 assign( frS128, unop( Iop_D64toD128, mkexpr( frB64 ) ) );
9561 putDReg_pair( frS_addr, mkexpr( frS128 ) );
9567 assign( frS64, binop( Iop_D128toI64S, round, mkexpr( frB128 ) ) );
9568 putDReg( frS_addr, mkexpr( frS64 ) );
9574 assign( frS64, binop( Iop_D128toD64, round, mkexpr( frB128 ) ) );
9575 putDReg( frS_addr, mkexpr( frS64 ) );
9585 assign( frS128, unop( Iop_I64StoD128, mkexpr( frB64 ) ) );
9586 putDReg_pair( frS_addr, mkexpr( frS128 ) );
9623 mkexpr( frB ) ) );
9624 putDReg( frS_addr, mkexpr( frS ) );
9664 mkexpr( frB ) ) );
9665 putDReg_pair( frS_addr, mkexpr( frS ) );
9723 assign( frA, binop( Iop_InsertExpD64, mkexpr( TE_D64 ),
9728 mkexpr( frA ),
9729 mkexpr( frB ) ) );
9738 mkexpr( frA ),
9739 mkexpr( frB ) ) );
9747 mkexpr( frA ),
9748 mkexpr( frB ) ) );
9754 putDReg( frS_addr, mkexpr( frS ) );
9809 binop( Iop_InsertExpD128, mkexpr( TE_D64 ),
9814 mkexpr( frA ),
9815 mkexpr( frB ) ) );
9823 mkexpr( frA ),
9824 mkexpr( frB ) ) );
9832 mkexpr( frA ),
9833 mkexpr( frB ) ) );
9839 putDReg_pair( frS_addr, mkexpr( frS ) );
9868 assign( frS, unop( Iop_ExtractExpD64, mkexpr( frB ) ) );
9873 assign( frS, binop( Iop_InsertExpD64, mkexpr( frA ), mkexpr( frB ) ) );
9880 putDReg( frS_addr, mkexpr( frS ) );
9913 assign( frS64, unop( Iop_ExtractExpD128, mkexpr( frB ) ) );
9914 putDReg( frS_addr, mkexpr( frS64 ) );
9920 assign( frS, binop( Iop_InsertExpD128, mkexpr( frA ), mkexpr( frB ) ) );
9921 putDReg_pair( frS_addr, mkexpr( frS ) );
9961 assign( ccIR, binop( Iop_CmpD64, mkexpr( frA ), mkexpr( frB ) ) );
9970 assign( ccIR, binop( Iop_CmpD128, mkexpr( frA ), mkexpr( frB ) ) );
9995 mkexpr( ccIR ),
10000 mkexpr( ccIR ),
10002 mkexpr( ccIR ),
10006 putGST_field( PPC_GST_CR, mkexpr( ccPPC32 ), crfD );
10051 mkexpr( frA ) ) ) ) );
10055 mkexpr( frB ) ) ) ) );
10062 assign( frA, unop( Iop_D128HItoD64, mkexpr( frA128 ) ) );
10063 assign( frB, unop( Iop_D128HItoD64, mkexpr( frB128 ) ) );
10068 mkexpr( frA128 ) ) ) ) );
10072 mkexpr( frB128 ) ) ) ) );
10081 mkexpr( gfield_mask ),
10084 mkexpr(frA) ) ) ) );
10087 mkexpr( gfield_mask ),
10090 mkexpr(frB) ) ) ) );
10096 mkexpr( gfield_A ),
10100 mkexpr( gfield_A ),
10106 mkexpr( gfield_B ),
10110 mkexpr( gfield_B ),
10118 mkexpr( gfield_A ),
10124 mkexpr( gfield_B ),
10131 mkexpr( A_NaN_true ),
10132 mkexpr( B_NaN_true ) ),
10134 mkexpr( A_inf_true ),
10135 mkexpr( B_inf_true ) ) ) ) );
10146 mkexpr( exponent_A ),
10147 mkexpr( exponent_B ) ) ),
10150 mkexpr( A_inf_true ),
10151 mkexpr( B_inf_true ) ),
10153 mkexpr( A_NaN_true ),
10154 mkexpr( B_NaN_true ) ) ) ) );
10157 mkexpr( finite_number ),
10161 mkexpr( exponent_A ),
10162 mkexpr( exponent_B ) ) ),
10166 mkexpr( finite_number ),
10170 mkexpr( exponent_B ),
10171 mkexpr( exponent_A ) ) ),
10176 mkexpr( A_equals_B ),
10181 unop( Iop_Not32, mkexpr( A_equals_B ) ),
10186 mkexpr ( A_inf_true ),
10187 mkexpr ( B_inf_true ) ),
10189 mkexpr ( A_NaN_true ),
10190 mkexpr ( B_NaN_true ) ) )
10196 mkexpr( cc0 ),
10198 mkexpr( cc1 ),
10200 mkexpr( cc2 ),
10201 mkexpr( cc3 ) ) ) ),
10270 assign( frAI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frA ) ) );
10275 mkexpr( frA ) ),
10291 mkexpr( frA ) ) ) ) );
10299 mkexpr( exp_min_normal ),
10300 mkexpr( significand64 ) ) );
10304 mkexpr( abs_frA ),
10305 mkexpr( min_subnormalD64 ) ) );
10310 mkexpr( abs_frA ),
10344 mkexpr( exp_min_normal ),
10345 mkexpr( significand128 ) ) );
10353 mkexpr( frA ) ),
10356 mkexpr( min_subnormalD128 ) ) );
10360 mkexpr( abs_frA ),
10378 mkexpr( gfield_mask ),
10380 mkexpr(frAI64_hi) ) ) );
10397 mkexpr( gfield ) ),
10405 mkexpr( gfield ) ),
10414 mkexpr( gfield ) ),
10417 mkexpr( SNaN_true ) ) ) );
10423 mkexpr( ccIR_zero ),
10427 mkexpr( infinity_true ),
10429 mkexpr( QNaN_true ),
10430 mkexpr( SNaN_true ) ) ) ) ) );
10440 mkexpr( ccIR_subnormal ),
10444 mkexpr( ccIR_subnormal ),
10449 mkexpr( infinity_true ),
10450 mkexpr( zero_true) ),
10452 mkexpr( QNaN_true ),
10453 mkexpr( SNaN_true ) ) ) ) ) );
10460 mkexpr( infinity_true ),
10461 mkexpr( zero_true ) ),
10463 mkexpr( subnormal_true ),
10465 mkexpr( QNaN_true ),
10466 mkexpr( SNaN_true ) ) ) ) ) );
10482 mkexpr( zero_true ),
10486 mkexpr( subnormal_true ),
10491 mkexpr( normal_true ),
10496 mkexpr( infinity_true),
10501 mkexpr( QNaN_true ),
10504 assign( dcm5, binop( Iop_And32, mkexpr( SNaN_true), mkU32( 1 ) ) );
10511 mkexpr( exponent ),
10515 mkexpr( exponent ),
10520 mkexpr( gfield ), mkU8( 31 - 5 ) ) );
10524 mkexpr( lmd ),
10541 mkexpr( extreme_true ) ),
10542 mkexpr( zero_true ) ),
10549 mkexpr( extreme_true ),
10550 mkexpr( zero_true ) ),
10558 mkexpr( extreme_true ),
10559 mkexpr( normal_true ) ),
10560 mkexpr( subnormal_true ) ),
10569 mkexpr( extreme_true ) ),
10570 mkexpr( normal_true ) ),
10573 mkexpr( lmd ),
10583 mkexpr( extreme_true ) ),
10584 mkexpr( normal_true ) ),
10587 mkexpr( lmd ),
10594 mkexpr( SNaN_true),
10596 mkexpr( QNaN_true),
10597 mkexpr( infinity_true) ) ),
10604 mkexpr( dcm0 ),
10606 mkexpr( dcm1 ),
10608 mkexpr( dcm2 ),
10610 mkexpr( dcm3 ),
10612 mkexpr( dcm4 ),
10613 mkexpr( dcm5 ) ) ) ) ) ) );
10620 unop( Iop_64HIto32, mkexpr( frAI64_hi ) ),
10639 mkexpr( sign ),
10646 mkexpr( DCM_calc ) ),
10650 putGST_field( PPC_GST_CR, mkexpr( field ), crfD );
10672 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
10678 assign( bcd64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
10679 assign( bcd_u, unop( Iop_64HIto32, mkexpr( bcd64 ) ) );
10680 assign( bcd_l, unop( Iop_64to32, mkexpr( bcd64 ) ) );
10686 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
10692 binop( Iop_Shl32, mkexpr( lmd ), mkU8( 28 ) ),
10693 mkexpr( bcd_u ) ),
10694 mkexpr( bcd_l ) ) );
10709 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
10721 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
10725 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
10738 mkexpr( bcd_l ),
10741 mkexpr( bcd_u ),
10744 mkexpr( sign ),
10746 mkexpr( bcd_l ),
10750 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result ) ) );
10767 assign( dbcd64, unop( Iop_BCDtoDPB, mkexpr(frBI64 ) ) );
10768 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( dbcd64 ) ) );
10769 assign( dbcd_l, unop( Iop_64to32, mkexpr( dbcd64 ) ) );
10774 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
10779 bcd_digit_inval( unop( Iop_64HIto32, mkexpr( frBI64 ) ),
10780 unop( Iop_64to32, mkexpr( frBI64 ) ) ) );
10781 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
10790 mkexpr( dbcd_u ),
10791 mkexpr( dbcd_l ) ) ) ) ) );
10795 unop( Iop_64HIto32, mkexpr( without_lmd ) ),
10801 Gfield_encoding( mkexpr( left_exp ), mkexpr( lmd ) ),
10809 mkexpr( without_lmd ) ),
10811 mkexpr( g0_4 ) ),
10812 unop( Iop_64to32, mkexpr( without_lmd ) ) ) );
10828 mkexpr( frBI64 ) ),
10833 mkexpr( frBI64 ) ),
10837 mkexpr( frBI64 ) ),
10840 assign( dbcd_u, unop( Iop_64HIto32, mkexpr( tmp ) ) );
10841 assign( dbcd_l, unop( Iop_64to32, mkexpr( tmp ) ) );
10846 unop( Iop_64to32, mkexpr( frBI64 ) ),
10849 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
10850 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
10852 Generate_sign_bit( mkexpr( pos_sign_mask ),
10853 mkexpr( neg_sign_mask ) ) );
10861 mkexpr( frBI64 ) ),
10864 mkexpr( frBI64 ) ),
10866 mkexpr( pos_sign_mask ),
10867 mkexpr( neg_sign_mask ) ) );
10869 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
10880 mkexpr( dbcd_u ),
10881 mkexpr( sign_bit ) ),
10882 mkexpr( dbcd_l ) ) ) ) ) );
10893 mkexpr( valid_mask ),
10895 mkexpr( tmp64 ) ) ),
10898 mkexpr( invalid_mask ) ) ),
10901 mkexpr( valid_mask ),
10902 unop( Iop_64to32, mkexpr( tmp64 ) ) ),
10905 mkexpr( invalid_mask ) ) ) ) ) );
10906 putDReg( frT_addr, mkexpr( resultD64 ) );
10934 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
10935 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
10951 Generate_132_bit_bcd_string( mkexpr( frBI64_hi ),
10952 mkexpr( frBI64_lo ),
10965 mkexpr( top_12_l ),
10968 mkexpr( mid_60_u ),
10972 mkexpr( mid_60_u ),
10975 mkexpr( mid_60_l ),
10982 mkexpr( mid_60_l ),
10984 mkexpr( low_60_u ) ),
10985 mkexpr( low_60_l ) ) );
10999 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11012 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11016 assign( sign, binop( Iop_Or32, mkexpr( tmp32 ), mkU32( 0xD ) ) );
11026 mkexpr( top_12_l ),
11028 mkexpr( mid_60_u ) ),
11029 mkexpr( mid_60_l ) ) );
11035 mkexpr( low_60_u ),
11038 mkexpr( low_60_l ),
11042 mkexpr( low_60_l ),
11044 mkexpr( sign ) ) ) );
11047 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result_hi ) ) );
11049 unop( Iop_ReinterpI64asD64, mkexpr( result_lo ) ) );
11086 mkexpr( frBI64_hi ) ),
11094 mkexpr( frBI64_hi ) ),
11098 mkexpr( frBI64_hi ) ),
11103 mkexpr( frBI64_hi ) ),
11107 mkexpr( frBI64_lo ) ),
11111 assign( bcd_low_60, mkexpr( frBI64_lo ) );
11113 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr( bcd_top_8 ) ) );
11114 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
11116 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr( bcd_mid_60 ) ) );
11117 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
11118 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
11120 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
11121 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
11122 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
11134 mkexpr( bcd_top_8 ) ) ),
11137 mkexpr( bcd_mid_60 ) ),
11139 mkexpr( bcd_mid_60 ) ) ),
11141 mkexpr( bcd_low_60 ) ),
11143 mkexpr( bcd_low_60 ) )
11155 unop( Iop_64to32, mkexpr( frBI64_lo ) ),
11157 assign( neg_sign_mask, Generate_neg_sign_mask( mkexpr( sign ) ) );
11158 assign( pos_sign_mask, Generate_pos_sign_mask( mkexpr( sign ) ) );
11160 Generate_sign_bit( mkexpr( pos_sign_mask ),
11161 mkexpr( neg_sign_mask ) ) );
11168 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11172 assign( bcd_mid_60, mkexpr( frBI64_hi ) );
11179 mkexpr( frBI64_lo ) ),
11184 mkexpr( frBI64_lo ) ),
11188 mkexpr( frBI64_lo ) ),
11190 assign( tmptop10, unop( Iop_BCDtoDPB, mkexpr(bcd_top_8 ) ) );
11191 assign( dbcd_top_l, unop( Iop_64to32, mkexpr( tmptop10 ) ) );
11193 assign( tmpmid50, unop( Iop_BCDtoDPB, mkexpr(bcd_mid_60 ) ) );
11194 assign( dbcd_mid_u, unop( Iop_64HIto32, mkexpr( tmpmid50 ) ) );
11195 assign( dbcd_mid_l, unop( Iop_64to32, mkexpr( tmpmid50 ) ) );
11197 assign( tmplow50, unop( Iop_BCDtoDPB, mkexpr( bcd_low_60 ) ) );
11198 assign( dbcd_low_u, unop( Iop_64HIto32, mkexpr( tmplow50 ) ) );
11199 assign( dbcd_low_l, unop( Iop_64to32, mkexpr( tmplow50 ) ) );
11212 bcd_digit_inval( mkexpr( zero ),
11214 mkexpr( bcd_top_8 ) ) ),
11217 mkexpr( bcd_mid_60 ) ),
11219 mkexpr( bcd_mid_60 ) ) ),
11221 mkexpr( frBI64_lo ) ),
11224 mkexpr( frBI64_lo ) ),
11227 Generate_inv_mask( mkexpr( inval_bcd_digit_mask ),
11228 mkexpr( pos_sign_mask ),
11229 mkexpr( neg_sign_mask ) ) );
11233 assign( valid_mask, unop( Iop_Not32, mkexpr( invalid_mask ) ) );
11243 mkexpr( sign_bit ),
11244 mkexpr( dbcd_top_l ) ),
11247 mkexpr( dbcd_mid_u ),
11250 mkexpr( dbcd_mid_l ),
11255 mkexpr( dbcd_low_u ),
11257 mkexpr( dbcd_mid_l ),
11259 mkexpr( dbcd_low_l ) ) ) ) );
11268 mkexpr( dfp_significand ) ) );
11272 unop( Iop_D128HItoD64, mkexpr( result128 ) ) ) );
11276 unop( Iop_D128LOtoD64, mkexpr( result128 ) ) ) );
11282 mkexpr( valid_mask ),
11283 unop( Iop_64HIto32, mkexpr
11286 mkexpr( invalid_mask ) ) ),
11289 mkexpr( valid_mask ),
11290 unop( Iop_64to32, mkexpr( tmp_hi ) ) ),
11293 mkexpr( invalid_mask ) ) ) ) );
11299 mkexpr( valid_mask ),
11300 unop( Iop_64HIto32, mkexpr( tmp_lo ) ) ),
11303 mkexpr( invalid_mask ) ) ),
11306 mkexpr( valid_mask ),
11307 unop( Iop_64to32, mkexpr( tmp_lo ) ) ),
11310 mkexpr( invalid_mask ) ) ) ) );
11312 putDReg( frT_addr, unop( Iop_ReinterpI64asD64, mkexpr( result_hi ) ) );
11314 unop( Iop_ReinterpI64asD64, mkexpr( result_lo ) ) );
11353 mkexpr( frA ) ) ),
11368 assign( frBI64, unop( Iop_ReinterpD64asI64, mkexpr( frB ) ) );
11377 unop( Iop_64HIto32, mkexpr( frBI64 ) ),
11380 assign( tmp64, unop( Iop_DPBtoBCD, mkexpr( frBI64 ) ) );
11381 assign( B_bcd_u, unop( Iop_64HIto32, mkexpr( tmp64 ) ) );
11382 assign( B_bcd_l, unop( Iop_64to32, mkexpr( tmp64 ) ) );
11387 Count_leading_zeros_60( mkexpr( lmd_B ),
11388 mkexpr( B_bcd_u ),
11389 mkexpr( B_bcd_l ) ) ) );
11390 assign( Unordered_true, Check_unordered( mkexpr( frBI64 ) ) );
11410 assign( frBI64_hi, unop( Iop_ReinterpD64asI64, mkexpr( frB_hi ) ) );
11411 assign( frBI64_lo, unop( Iop_ReinterpD64asI64, mkexpr( frB_lo ) ) );
11420 unop( Iop_64HIto32, mkexpr( frBI64_hi ) ),
11423 Generate_132_bit_bcd_string( mkexpr( frBI64_hi ),
11424 mkexpr( frBI64_lo ),
11434 Count_leading_zeros_128( mkexpr( lmd_B ),
11435 mkexpr( B_top_12_l ),
11436 mkexpr( B_mid_60_u ),
11437 mkexpr( B_mid_60_l ),
11438 mkexpr( B_low_60_u ),
11439 mkexpr( B_low_60_l ) ) ) );
11441 assign( Unordered_true, Check_unordered( mkexpr( frBI64_hi ) ) );
11460 unop( Iop_8Uto32, mkexpr( K ) ),
11461 unop( Iop_8Uto32, mkexpr( B_sig ) ) ) ) );
11465 unop( Iop_8Uto32, mkexpr( K ) ),
11466 unop( Iop_8Uto32, mkexpr( B_sig ) ) ) ) );
11470 unop( Iop_8Uto32, mkexpr( B_sig ) ),
11471 unop( Iop_8Uto32, mkexpr( K ) ) ) ) );
11476 unop( Iop_8Uto32, mkexpr( K ) ),
11481 unop( Iop_8Uto32, mkexpr( K ) ),
11487 mkexpr( KisZero_false_mask ),
11490 mkexpr( Lt_true_mask ),
11494 mkexpr( Gt_true_mask ),
11497 mkexpr( Eq_true_mask ),
11500 mkexpr( KisZero_true_mask ),
11506 mkexpr( Unordered_true ),
11509 unop( Iop_Not32, mkexpr( Unordered_true ) ),
11510 mkexpr( field ) ) ),
11606 putGST( PPC_GST_VSCR, unop(Iop_V128to32, mkexpr(vB)) );
11701 mkexpr( xB ) ), mkU64( 0 ) ) );
11711 mkexpr( xB ) ) ),
11721 mkexpr( xB ) ),
11731 mkexpr( xB ) ) ),
11741 mkexpr( xB ) ) ),
11752 assign(hiResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB)));
11753 assign(loResult_32, binop(Iop_F64toI32S, rmZero, mkexpr(xB2)));
11756 unop( Iop_32Sto64, mkexpr( hiResult_32 ) ),
11757 unop( Iop_32Sto64, mkexpr( loResult_32 ) ) ) );
11779 assign( hi64, unop(Iop_V128HIto64, mkexpr(tempResult)) );
11780 assign( lo64, unop(Iop_V128to64, mkexpr(tempResult)) );
11781 assign( res3, unop(Iop_64HIto32, mkexpr(hi64)) );
11782 assign( res2, unop(Iop_64to32, mkexpr(hi64)) );
11783 assign( res1, unop(Iop_64HIto32, mkexpr(lo64)) );
11784 assign( res0, unop(Iop_64to32, mkexpr(lo64)) );
11788 mkexpr(res3),
11793 mkexpr(res2),
11798 mkexpr(res1),
11803 mkexpr(res0),
11823 mkexpr( xB ) ) ) ),
11836 mkexpr( xB ) ) ),
11845 unop( Iop_ReinterpI32asF32, mkexpr( xB ) ) ) ),
11858 mkexpr( xB ) ) ) ),
11865 mkexpr( xB2 ) ) ) ),
11874 binop( Iop_F64toI64U, mkU32( Irrm_ZERO ), mkexpr( xB ) ),
11875 binop( Iop_F64toI64U, mkU32( Irrm_ZERO ), mkexpr( xB2 ) ) ) );
11885 mkexpr( xB ) ),
11890 mkexpr( xB2 ) ),
11899 unop( Iop_ReinterpI32asF32, mkexpr( b3 ) ) ) ),
11902 unop( Iop_ReinterpI32asF32, mkexpr( b1 ) ) ) ) ) );
11912 unop( Iop_ReinterpI32asF32, mkexpr( b3 ) ) ) ),
11916 unop( Iop_ReinterpI32asF32, mkexpr( b1 ) ) ) ) ) );
11926 unop( Iop_ReinterpI32asF32, mkexpr( b3 ) ) ) ),
11930 unop( Iop_ReinterpI32asF32, mkexpr( b1 ) ) ) ) ) );
11937 binop( Iop_F64toI64S, mkU32( Irrm_ZERO ), mkexpr( xB ) ),
11938 binop( Iop_F64toI64S, mkU32( Irrm_ZERO ), mkexpr( xB2 ) ) ) );
11948 mkexpr( xB ) ) ),
11952 mkexpr( xB2 ) ) ) ) );
11962 mkexpr( xB ) ) ),
11966 mkexpr( xB2 ) ) ) ) );
11981 mkexpr( xB ) ) ) ) ),
11990 mkexpr( xB2 ) ) ) ) ),
12005 mkexpr( xB ) ) ) ) ),
12014 mkexpr( xB2 ) ) ) ) ),
12024 unop( Iop_32Sto64, mkexpr( b3 ) ) ) ),
12027 unop( Iop_32Sto64, mkexpr( b1 ) ) ) ) ) );
12035 unop( Iop_32Uto64, mkexpr( b3 ) ) ) ),
12038 unop( Iop_32Uto64, mkexpr( b1 ) ) ) ) ) );
12118 triop( mOp, rm, mkexpr( frA ), mkexpr( frB ) ) ) );
12121 triop( mOp, rm, mkexpr( frA2 ), mkexpr( frB2 ) ) ) );
12123 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
12134 binop( Iop_SqrtF64, rm, mkexpr( frB ) ) ) );
12137 binop( Iop_SqrtF64, rm, mkexpr( frB2 ) ) ) );
12139 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
12202 mkexpr( frA ),
12203 mkexpr( mdp ? frT : frB ),
12204 mkexpr( mdp ? frB : frT ) ) ) );
12209 mkexpr( frA2 ),
12210 mkexpr( mdp ? frT2 : frB2 ),
12211 mkexpr( mdp ? frB2 : frT2 ) ) ) );
12214 mkexpr( negate ? getNegatedResult( hiResult )
12216 mkexpr( negate ? getNegatedResult( loResult )
12241 binop( Iop_Shl32, mkexpr(fg_flagHi), mkU8( 2 ) ) ),
12242 binop( Iop_Shl32, mkexpr(fe_flagHi), mkU8( 1 ) ) ) );
12246 binop( Iop_Shl32, mkexpr(fg_flagLo), mkU8( 2 ) ) ),
12247 binop( Iop_Shl32, mkexpr(fe_flagLo), mkU8( 1 ) ) ) );
12249 binop( Iop_Or32, mkexpr( flagsHi ), mkexpr( flagsLo ) ),
12279 binop( Iop_Shl32, mkexpr(fg_flagHi), mkU8( 2 ) ) ),
12280 binop( Iop_Shl32, mkexpr(fe_flagHi), mkU8( 1 ) ) ) );
12284 binop( Iop_Shl32, mkexpr(fg_flagLo), mkU8( 2 ) ) ),
12285 binop( Iop_Shl32, mkexpr(fe_flagLo), mkU8( 1 ) ) ) );
12287 binop( Iop_Or32, mkexpr( flagsHi ), mkexpr( flagsLo ) ),
12359 triop( Iop_DivF64r32, rm, mkexpr( a0 ), mkexpr( b0 ) ) ) ) );
12363 triop( Iop_DivF64r32, rm, mkexpr( a1 ), mkexpr( b1 ) ) ) ) );
12367 triop( Iop_DivF64r32, rm, mkexpr( a2 ), mkexpr( b2 ) ) ) ) );
12371 triop( Iop_DivF64r32, rm, mkexpr( a3 ), mkexpr( b3 ) ) ) ) );
12375 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
12376 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
12392 binop(Iop_SqrtF64, rm, mkexpr( b0 ) ) ) ) );
12396 binop(Iop_SqrtF64, rm, mkexpr( b1 ) ) ) ) );
12400 binop(Iop_SqrtF64, rm, mkexpr( b2) ) ) ) );
12404 binop(Iop_SqrtF64, rm, mkexpr( b3 ) ) ) ) );
12408 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
12409 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
12465 mkexpr( a0 ),
12466 mkexpr( msp ? t0 : b0 ),
12467 mkexpr( msp ? b0 : t0 ) ) ) ) );
12473 mkexpr( a1 ),
12474 mkexpr( msp ? t1 : b1 ),
12475 mkexpr( msp ? b1 : t1 ) ) ) ) );
12481 mkexpr( a2 ),
12482 mkexpr( msp ? t2 : b2 ),
12483 mkexpr( msp ? b2 : t2 ) ) ) ) );
12489 mkexpr( a3 ),
12490 mkexpr( msp ? t3 : b3 ),
12491 mkexpr( msp ? b3 : t3 ) ) ) ) );
12495 binop( Iop_32HLto64, mkexpr( negate ? getNegatedResult_32( res3 ) : res3 ),
12496 mkexpr( negate ? getNegatedResult_32( res2 ) : res2 ) ),
12497 binop( Iop_32HLto64, mkexpr( negate ? getNegatedResult_32( res1 ) : res1 ),
12498 mkexpr( negate ? getNegatedResult_32( res0 ) : res0 ) ) ) );
12527 binop( Iop_Shl32, mkexpr(fg_flag0), mkU8( 2 ) ) ),
12528 binop( Iop_Shl32, mkexpr(fe_flag0), mkU8( 1 ) ) ) );
12532 binop( Iop_Shl32, mkexpr(fg_flag1), mkU8( 2 ) ) ),
12533 binop( Iop_Shl32, mkexpr(fe_flag1), mkU8( 1 ) ) ) );
12537 binop( Iop_Shl32, mkexpr(fg_flag2), mkU8( 2 ) ) ),
12538 binop( Iop_Shl32, mkexpr(fe_flag2), mkU8( 1 ) ) ) );
12542 binop( Iop_Shl32, mkexpr(fg_flag3), mkU8( 2 ) ) ),
12543 binop( Iop_Shl32, mkexpr(fe_flag3), mkU8( 1 ) ) ) );
12546 mkexpr( flags0 ),
12548 mkexpr( flags1 ),
12550 mkexpr( flags2 ),
12551 mkexpr( flags3 ) ) ) ),
12582 binop( Iop_Shl32, mkexpr(fg_flag0), mkU8( 2 ) ) ),
12583 binop( Iop_Shl32, mkexpr(fe_flag0), mkU8( 1 ) ) ) );
12587 binop( Iop_Shl32, mkexpr(fg_flag1), mkU8( 2 ) ) ),
12588 binop( Iop_Shl32, mkexpr(fe_flag1), mkU8( 1 ) ) ) );
12592 binop( Iop_Shl32, mkexpr(fg_flag2), mkU8( 2 ) ) ),
12593 binop( Iop_Shl32, mkexpr(fe_flag2), mkU8( 1 ) ) ) );
12597 binop( Iop_Shl32, mkexpr(fg_flag3), mkU8( 2 ) ) ),
12598 binop( Iop_Shl32, mkexpr(fe_flag3), mkU8( 1 ) ) ) );
12601 mkexpr( flags0 ),
12603 mkexpr( flags1 ),
12605 mkexpr( flags2 ),
12606 mkexpr( flags3 ) ) ) ),
12659 mkexpr( ccIR ),
12664 mkexpr( ccIR ),
12666 mkexpr( ccIR ),
12693 mkAND1( mkexpr(frA_isNaN),
12696 unop( Iop_64HIto32, mkexpr( frA_I64 ) ),
12700 mkAND1( mkexpr(frB_isNaN),
12703 unop( Iop_64HIto32, mkexpr( frB_I64 ) ),
12707 mkAND1( mkexpr( frA_isNaN ), unop( Iop_Not1, mkexpr( frA_isSNaN ) ) ) );
12709 mkAND1( mkexpr( frB_isNaN ), unop( Iop_Not1, mkexpr( frB_isSNaN ) ) ) );
12728 IRExpr_Mux0X(unop(Iop_1Uto8, mkexpr(frA_isSNaN)),
12730 IRExpr_Mux0X(unop(Iop_1Uto8, mkexpr(frB_isSNaN)),
12732 IRExpr_Mux0X(unop(Iop_1Uto8, mkexpr(frB_isQNaN)),
12734 mkexpr(frB_I64),
12736 mkexpr(frA_I64)),
12738 binop(Iop_Or64, mkexpr(frB_I64), mkU64(SNAN_MASK))),
12740 binop(Iop_Or64, mkexpr(frA_I64), mkU64(SNAN_MASK)));
12750 mkexpr( src1 ) ),
12752 mkexpr( src2 ) ) ) );
12756 mkexpr( src1cmpsrc2 ),
12759 mkexpr( src2 ),
12761 mkexpr( src1 ) );
12790 mkAND1( mkexpr( frA_isZero ), mkexpr( frB_isZero ) ) ),
12792 IRExpr_Mux0X( unop( Iop_1Uto8, mkexpr( anyNaN ) ),
12803 mkexpr( frA_I64 ) ),
12805 mkexpr( frB_I64 ),
12848 assign(frB, unop(Iop_ReinterpI64asF64, mkexpr(frB_I64)));
12851 mkexpr( frB ) ) );
12862 unop( Iop_AbsF64, mkexpr( frB ) ) ) ),
12866 mkexpr( frB_I64 ) ),
12870 mkexpr( intermediateResult ) ),
12875 mkexpr( intermediateResult ) ) ) ) ),
12876 mkexpr( frB ) ) );
12882 hi32 = unop( Iop_64HIto32, mkexpr(frB_I64) );
12889 return IRExpr_Mux0X( unop( Iop_1Uto8, mkexpr( is_SNAN ) ),
12890 mkexpr( frD ),
12894 mkexpr( frB_I64 ) ) ) );
12933 unop( Iop_ReinterpI64asF64, mkexpr( frB ) ) ) );
12937 unop( Iop_ReinterpI64asF64, mkexpr( frB2 ) ) ) );
12946 mkexpr( frB ) )
12947 : mkexpr( sqrtHi ) ) ),
12953 mkexpr( frB2 ) )
12954 : mkexpr( sqrtLo ) ) ) ) );
12980 assign( sqrt3, binop( Iop_SqrtF64, rm, mkexpr( b3 ) ) );
12981 assign( sqrt2, binop( Iop_SqrtF64, rm, mkexpr( b2 ) ) );
12982 assign( sqrt1, binop( Iop_SqrtF64, rm, mkexpr( b1 ) ) );
12983 assign( sqrt0, binop( Iop_SqrtF64, rm, mkexpr( b0 ) ) );
12992 resp ? mkexpr( b0 ) : mkexpr( sqrt0 ) ) ) ) );
12999 resp ? mkexpr( b1 ) : mkexpr( sqrt1 ) ) ) ) );
13006 resp ? mkexpr( b2 ) : mkexpr( sqrt2 ) ) ) ) );
13013 resp ? mkexpr( b3 ) : mkexpr( sqrt3 ) ) ) ) );
13016 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
13017 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
13046 assign( a0_I64, unop( Iop_ReinterpF64asI64, mkexpr( a0 ) ) );
13047 assign( b0_I64, unop( Iop_ReinterpF64asI64, mkexpr( b0 ) ) );
13048 assign( a1_I64, unop( Iop_ReinterpF64asI64, mkexpr( a1 ) ) );
13049 assign( b1_I64, unop( Iop_ReinterpF64asI64, mkexpr( b1 ) ) );
13050 assign( a2_I64, unop( Iop_ReinterpF64asI64, mkexpr( a2 ) ) );
13051 assign( b2_I64, unop( Iop_ReinterpF64asI64, mkexpr( b2 ) ) );
13052 assign( a3_I64, unop( Iop_ReinterpF64asI64, mkexpr( a3 ) ) );
13053 assign( b3_I64, unop( Iop_ReinterpF64asI64, mkexpr( b3 ) ) );
13076 binop( Iop_32HLto64, mkexpr( res3 ), mkexpr( res2 ) ),
13077 binop( Iop_32HLto64, mkexpr( res1 ), mkexpr( res0 ) ) ) );
13116 mkexpr( frA ),
13119 mkexpr( frB ),
13123 mkexpr( frA2 ),
13126 mkexpr( frB2 ),
13148 unop(Iop_64to32, mkexpr( a3_I64 ) ),
13151 unop(Iop_64to32, mkexpr( b3_I64 ) ),
13156 unop(Iop_64to32, mkexpr( a2_I64 ) ),
13159 unop(Iop_64to32, mkexpr( b2_I64 ) ),
13165 unop(Iop_64to32, mkexpr( a1_I64 ) ),
13168 unop(Iop_64to32, mkexpr( b1_I64 ) ),
13173 unop(Iop_64to32, mkexpr( a0_I64 ) ),
13176 unop(Iop_64to32, mkexpr( b0_I64 ) ),
13178 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( resHi ), mkexpr( resLo ) ) );
13194 assign(abs_resultHi, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB ) ) ) );
13195 assign(abs_resultLo, unop( Iop_NegF64, unop( Iop_AbsF64, mkexpr( frB2 ) ) ) );
13198 assign(abs_resultHi, unop( Iop_AbsF64, mkexpr( frB ) ) );
13199 assign(abs_resultLo, unop( Iop_AbsF64, mkexpr( frB2 ) ) );
13202 unop( Iop_ReinterpF64asI64, mkexpr( abs_resultHi ) ),
13203 unop( Iop_ReinterpF64asI64, mkexpr( abs_resultLo ) ) ) );
13226 mkexpr( shiftVector ) ),
13227 mkexpr( shiftVector ) ) );
13240 mkexpr( absVal_vector ),
13241 mkexpr( signBit_vector ) ) );
13243 putVSReg( XT, mkexpr( absVal_vector ) );
13257 unop( Iop_NegF64, mkexpr( frB ) ) ),
13259 unop( Iop_NegF64, mkexpr( frB2 ) ) ) ) );
13332 assign(b3_I64, unop(Iop_ReinterpF64asI64, mkexpr(b3_F64)));
13333 assign(b2_I64, unop(Iop_ReinterpF64asI64, mkexpr(b2_F64)));
13334 assign(b1_I64, unop(Iop_ReinterpF64asI64, mkexpr(b1_F64)));
13335 assign(b0_I64, unop(Iop_ReinterpF64asI64, mkexpr(b0_F64)));
13397 mkexpr( frA ),
13398 mkexpr( frB ) ) ),
13405 mkexpr( frA ),
13406 mkexpr( frB ) ) ),
13418 mkexpr( frA ),
13419 mkexpr( mdp ? frT : frB ),
13420 mkexpr( mdp ? frB : frT ) ) ),
13433 mkexpr( frA ),
13434 mkexpr( mdp ? frT : frB ),
13435 mkexpr( mdp ? frB : frT ) ) ),
13456 mkexpr( frA ),
13457 mkexpr( mdp ? frT : frB ),
13458 mkexpr( mdp ? frB : frT ) ) ) );
13460 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( getNegatedResult(maddResult) ),
13476 mkexpr( frA ),
13477 mkexpr( mdp ? frT : frB ),
13478 mkexpr( mdp ? frB : frT ) ) ));
13480 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( getNegatedResult(msubResult) ), mkU64( 0 ) ) );
13489 mkexpr( frA ),
13490 mkexpr( frB ) ) ),
13497 mkexpr( frA ),
13498 mkexpr( frB ) ) ),
13506 mkexpr( frB ) ) ),
13516 assign( frA_I64, unop( Iop_ReinterpF64asI64, mkexpr( frA ) ) );
13517 assign( frB_I64, unop( Iop_ReinterpF64asI64, mkexpr( frB ) ) );
13537 binop( Iop_Shl32, mkexpr(fg_flag), mkU8( 2 ) ) ),
13538 binop( Iop_Shl32, mkexpr(fe_flag), mkU8( 1 ) ) ) );
13539 putGST_field( PPC_GST_CR, mkexpr(flags), crfD );
13580 ccPPC32 = get_fp_cmp_CR_val( binop(Iop_CmpF64, mkexpr(frA), mkexpr(frB)));
13581 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), crfD );
13609 assign(frA_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vA ))));
13610 assign(frB_hi, unop(Iop_ReinterpI64asF64, unop(Iop_V128HIto64, mkexpr( vB ))));
13611 assign(frA_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vA ))));
13612 assign(frB_lo, unop(Iop_ReinterpI64asF64, unop(Iop_V128to64, mkexpr( vB ))));
13615 mkexpr( frA_hi ),
13616 mkexpr( frB_hi ) ) );
13618 mkexpr( frA_lo ),
13619 mkexpr( frB_lo ) ) );
13624 binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( cmp_type ) ) ) );
13627 binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( cmp_type ) ) ) );
13634 assign(hi_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 2 ) ),
13635 binop( Iop_CmpEQ32, mkexpr( ccIR_hi ), mkU32( 4 ) ) ) );
13636 assign( hiResult,unop( Iop_1Sto64, mkexpr( hi_GE ) ) );
13638 assign(lo_GE, mkOR1( binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 2 ) ),
13639 binop( Iop_CmpEQ32, mkexpr( ccIR_lo ), mkU32( 4 ) ) ) );
13640 assign( loResult, unop( Iop_1Sto64, mkexpr( lo_GE ) ) );
13646 unop( Iop_64to32, mkexpr( hiResult ) ),
13647 unop( Iop_64to32, mkexpr( loResult ) ) ) );
13649 binop( Iop_64HLtoV128, mkexpr( hiResult ), mkexpr( loResult ) ) );
13653 mkAND1( mkexpr( hiEQlo ),
13657 mkexpr( hiResult ) ) ) ) ) );
13661 mkAND1( mkexpr( hiEQlo ),
13665 mkexpr( hiResult ) ) ) ) ) );
13668 binop( Iop_Shl32, mkexpr( all_elem_false ), mkU8( 1 ) ),
13669 binop( Iop_Shl32, mkexpr( all_elem_true ), mkU8( 3 ) ) ) );
13672 putGST_field( PPC_GST_CR, mkexpr(ccPPC32), 6 );
13730 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
13731 putVSReg( XT, mkexpr(vD) );
13733 set_AV_CR6( mkexpr(vD), True );
13744 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
13745 putVSReg( XT, mkexpr(vD) );
13747 set_AV_CR6( mkexpr(vD), True );
13758 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
13759 putVSReg( XT, mkexpr(vD) );
13761 set_AV_CR6( mkexpr(vD), True );
13804 assign(absVal, binop(Iop_ShrV128, binop(Iop_ShlV128, mkexpr(vB), mkU8(1)), mkU8(1)));
13806 putVSReg(XT, mkexpr(absVal));
13817 mkexpr( vB ),
13821 mkexpr( vA ),
13824 assign( vec_result, binop( Iop_OrV128, mkexpr(vecA_signbit), mkexpr( vecB_no_signbit ) ) );
13825 putVSReg(XT, mkexpr(vec_result));
13836 putVSReg(XT, binop(Iop_OrV128, mkexpr(vec_neg_signbit), mkexpr(vB)));
13846 mkexpr( vB ),
13852 mkexpr( vB ),
13855 putVSReg( XT, binop( Iop_OrV128, mkexpr( vecB_no_signbit ),
13856 mkexpr( vecB_signbit_comp ) ) );
13867 assign(frA, unop(Iop_V128HIto64, mkexpr( vA )));
13868 assign(frB, unop(Iop_V128HIto64, mkexpr( vB )));
13883 assign(frB_I64, unop(Iop_V128HIto64, mkexpr( vB )));
13905 unop( Iop_V128HIto64, mkexpr( vB ) ) ) );
13911 mkexpr(frB) ) );
13918 redp ? mkexpr( frB ) : mkexpr( sqrt ) ) ),
13955 putVSReg( XT, binop( Iop_XorV128, mkexpr( vA ), mkexpr( vB ) ) );
13959 putVSReg( XT, binop( Iop_OrV128, mkexpr( vA ), mkexpr( vB ) ) );
13963 putVSReg( XT, unop( Iop_NotV128, binop( Iop_OrV128, mkexpr( vA ),
13964 mkexpr( vB ) ) ) );
13968 putVSReg( XT, binop( Iop_AndV128, mkexpr( vA ), mkexpr( vB ) ) );
13972 putVSReg( XT, binop( Iop_AndV128, mkexpr( vA ), unop( Iop_NotV128,
13973 mkexpr( vB ) ) ) );
14011 exp = loadBE( Ity_I64, mkexpr( EA ) );
14025 high = loadBE( Ity_I64, mkexpr( EA ) );
14026 high_addr = binop( addOp, mkexpr( EA ), ty == Ity_I64 ? mkU64( ea_off )
14036 assign( data, loadBE( Ity_I64, mkexpr( EA ) ) );
14037 putVSReg( XT, binop( Iop_64HLtoV128, mkexpr( data ), mkexpr( data ) ) );
14047 t3 = loadBE( Ity_I32, mkexpr( EA ) );
14049 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14053 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14057 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14102 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
14103 storeBE( mkexpr( EA ), high64 );
14110 high64 = unop( Iop_V128HIto64, mkexpr( vS ) );
14111 low64 = unop( Iop_V128to64, mkexpr( vS ) );
14112 storeBE( mkexpr( EA ), high64 );
14113 storeBE( binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ), ty == Ity_I64 ? mkU64( 8 )
14128 assign( hi64, unop( Iop_V128HIto64, mkexpr( vS ) ) );
14129 assign( lo64, unop( Iop_V128to64, mkexpr( vS ) ) );
14131 storeBE( mkexpr( EA ), unop( Iop_64HIto32, mkexpr( hi64 ) ) );
14133 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14135 storeBE( irx_addr, unop( Iop_64to32, mkexpr( hi64 ) ) );
14137 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14139 storeBE( irx_addr, unop( Iop_64HIto32, mkexpr( lo64 ) ) );
14141 irx_addr = binop( mkSzOp( ty, Iop_Add8 ), mkexpr( EA ),
14143 storeBE( irx_addr, unop( Iop_64to32, mkexpr( lo64 ) ) );
14185 assign( hi, binop(Iop_ShlV128, mkexpr(vA), mkU8(SHW*32)) );
14186 assign( lo, binop(Iop_ShrV128, mkexpr(vB), mkU8(128-SHW*32)) );
14187 assign ( result, binop(Iop_OrV128, mkexpr(hi), mkexpr(lo)) );
14189 assign ( result, mkexpr(vA) );
14191 putVSReg( XT, mkexpr(result) );
14201 assign( hi, unop(Iop_V128to64, mkexpr(vA)) );
14203 assign( hi, unop(Iop_V128HIto64, mkexpr(vA)) );
14206 assign( lo, unop(Iop_V128to64, mkexpr(vB)) );
14208 assign( lo, unop(Iop_V128HIto64, mkexpr(vB)) );
14210 assign( vT, binop(Iop_64HLtoV128, mkexpr(hi), mkexpr(lo)) );
14213 putVSReg( XT, mkexpr( vT ) );
14228 assign( a64, unop(word_op, mkexpr(vA)) );
14229 assign( ahi32, unop(Iop_64HIto32, mkexpr(a64)) );
14230 assign( alo32, unop(Iop_64to32, mkexpr(a64)) );
14232 assign( b64, unop(word_op, mkexpr(vB)) );
14233 assign( bhi32, unop(Iop_64HIto32, mkexpr(b64)) );
14234 assign( blo32, unop(Iop_64to32, mkexpr(b64)) );
14237 binop(Iop_32HLto64, mkexpr(ahi32), mkexpr(bhi32)),
14238 binop(Iop_32HLto64, mkexpr(alo32), mkexpr(blo32))) );
14241 putVSReg( XT, mkexpr( vT ) );
14252 binop(Iop_AndV128, mkexpr(vA), unop(Iop_NotV128, mkexpr(vC))),
14253 binop(Iop_AndV128, mkexpr(vB), mkexpr(vC))) );
14264 binop( Iop_ShrV128, mkexpr( vB ), mkU8( sh_uim ) ) ) ) );
14298 assign( EA_align16, addr_align( mkexpr(EA), 16 ) );
14307 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
14341 binop(Iop_And32, mkNarrowTo32(ty, mkexpr(EA)),
14375 putVReg( vD_addr, loadBE(Ity_V128, mkexpr(EA_align16)) );
14381 putVReg( vD_addr, loadBE(Ity_V128, mkexpr(EA_align16)) );
14387 putVReg( vD_addr, loadBE(Ity_V128, mkexpr(EA_align16)) );
14392 putVReg( vD_addr, loadBE(Ity_V128, mkexpr(EA_align16)) );
14397 putVReg( vD_addr, loadBE(Ity_V128, mkexpr(EA_align16)) );
14440 mkNarrowTo32(ty, mkexpr(EA)) )) );
14442 binop(Iop_Sub8, mkU8(15), mkexpr(eb)),
14444 storeBE( mkexpr(EA),
14446 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx)))) );
14451 assign( addr_aligned, addr_align(mkexpr(EA), 2) );
14453 mkNarrowTo8(ty, mkexpr(addr_aligned) )) );
14455 binop(Iop_Sub8, mkU8(14), mkexpr(eb)),
14457 storeBE( mkexpr(addr_aligned),
14459 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx)))) );
14464 assign( addr_aligned, addr_align(mkexpr(EA), 4) );
14466 mkNarrowTo8(ty, mkexpr(addr_aligned) )) );
14468 binop(Iop_Sub8, mkU8(12), mkexpr(eb)),
14470 storeBE( mkexpr(addr_aligned),
14472 binop(Iop_ShrV128, mkexpr(vS), mkexpr(idx))) );
14478 storeBE( addr_align( mkexpr(EA), 16 ), mkexpr(vS) );
14483 storeBE( addr_align( mkexpr(EA), 16 ), mkexpr(vS) );
14535 binop(Iop_CmpGT32Ux4, mkexpr(vB),
14536 unop(Iop_NotV128, mkexpr(vA))),
14542 putVReg( vD_addr, binop(Iop_Add8x16, mkexpr(vA), mkexpr(vB)) );
14547 putVReg( vD_addr, binop(Iop_Add16x8, mkexpr(vA), mkexpr(vB)) );
14552 putVReg( vD_addr, binop(Iop_Add32x4, mkexpr(vA), mkexpr(vB)) );
14557 putVReg( vD_addr, binop(Iop_QAdd8Ux16, mkexpr(vA), mkexpr(vB)) );
14563 putVReg( vD_addr, binop(Iop_QAdd16Ux8, mkexpr(vA), mkexpr(vB)) );
14569 putVReg( vD_addr, binop(Iop_QAdd32Ux4, mkexpr(vA), mkexpr(vB)) );
14575 putVReg( vD_addr, binop(Iop_QAdd8Sx16, mkexpr(vA), mkexpr(vB)) );
14581 putVReg( vD_addr, binop(Iop_QAdd16Sx8, mkexpr(vA), mkexpr(vB)) );
14587 putVReg( vD_addr, binop(Iop_QAdd32Sx4, mkexpr(vA), mkexpr(vB)) );
14598 binop(Iop_CmpGT32Ux4, mkexpr(vB),
14599 mkexpr(vA))),
14605 putVReg( vD_addr, binop(Iop_Sub8x16, mkexpr(vA), mkexpr(vB)) );
14610 putVReg( vD_addr, binop(Iop_Sub16x8, mkexpr(vA), mkexpr(vB)) );
14615 putVReg( vD_addr, binop(Iop_Sub32x4, mkexpr(vA), mkexpr(vB)) );
14620 putVReg( vD_addr, binop(Iop_QSub8Ux16, mkexpr(vA), mkexpr(vB)) );
14626 putVReg( vD_addr, binop(Iop_QSub16Ux8, mkexpr(vA), mkexpr(vB)) );
14632 putVReg( vD_addr, binop(Iop_QSub32Ux4, mkexpr(vA), mkexpr(vB)) );
14638 putVReg( vD_addr, binop(Iop_QSub8Sx16, mkexpr(vA), mkexpr(vB)) );
14644 putVReg( vD_addr, binop(Iop_QSub16Sx8, mkexpr(vA), mkexpr(vB)) );
14650 putVReg( vD_addr, binop(Iop_QSub32Sx4, mkexpr(vA), mkexpr(vB)) );
14658 putVReg( vD_addr, binop(Iop_Max8Ux16, mkexpr(vA), mkexpr(vB)) );
14663 putVReg( vD_addr, binop(Iop_Max16Ux8, mkexpr(vA), mkexpr(vB)) );
14668 putVReg( vD_addr, binop(Iop_Max32Ux4, mkexpr(vA), mkexpr(vB)) );
14673 putVReg( vD_addr, binop(Iop_Max8Sx16, mkexpr(vA), mkexpr(vB)) );
14678 putVReg( vD_addr, binop(Iop_Max16Sx8, mkexpr(vA), mkexpr(vB)) );
14683 putVReg( vD_addr, binop(Iop_Max32Sx4, mkexpr(vA), mkexpr(vB)) );
14690 putVReg( vD_addr, binop(Iop_Min8Ux16, mkexpr(vA), mkexpr(vB)) );
14695 putVReg( vD_addr, binop(Iop_Min16Ux8, mkexpr(vA), mkexpr(vB)) );
14700 putVReg( vD_addr, binop(Iop_Min32Ux4, mkexpr(vA), mkexpr(vB)) );
14705 putVReg( vD_addr, binop(Iop_Min8Sx16, mkexpr(vA), mkexpr(vB)) );
14710 putVReg( vD_addr, binop(Iop_Min16Sx8, mkexpr(vA), mkexpr(vB)) );
14715 putVReg( vD_addr, binop(Iop_Min32Sx4, mkexpr(vA), mkexpr(vB)) );
14722 putVReg( vD_addr, binop(Iop_Avg8Ux16, mkexpr(vA), mkexpr(vB)) );
14727 putVReg( vD_addr, binop(Iop_Avg16Ux8, mkexpr(vA), mkexpr(vB)) );
14732 putVReg( vD_addr, binop(Iop_Avg32Ux4, mkexpr(vA), mkexpr(vB)) );
14737 putVReg( vD_addr, binop(Iop_Avg8Sx16, mkexpr(vA), mkexpr(vB)) );
14742 putVReg( vD_addr, binop(Iop_Avg16Sx8, mkexpr(vA), mkexpr(vB)) );
14747 putVReg( vD_addr, binop(Iop_Avg32Sx4, mkexpr(vA), mkexpr(vB)) );
14755 binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)));
14761 binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)));
14767 binop(Iop_MullEven8Sx16, mkexpr(vA), mkexpr(vB)));
14773 binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)));
14778 putVReg( vD_addr, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
14783 putVReg( vD_addr, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
14788 putVReg( vD_addr, MK_Iop_MullOdd8Sx16( mkexpr(vA), mkexpr(vB) ));
14793 putVReg( vD_addr, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
14804 expand8Ux16( mkexpr(vA), &aEvn, &aOdd ); // (15,13...),(14,12...)
14805 expand16Ux8( mkexpr(aEvn), &aEE, &aEO ); // (15,11...),(13, 9...)
14806 expand16Ux8( mkexpr(aOdd), &aOE, &aOO ); // (14,10...),(12, 8...)
14809 breakV128to4x64U( mkexpr(aEE), &a15, &a11, &a7, &a3 );
14810 breakV128to4x64U( mkexpr(aOE), &a14, &a10, &a6, &a2 );
14811 breakV128to4x64U( mkexpr(aEO), &a13, &a9, &a5, &a1 );
14812 breakV128to4x64U( mkexpr(aOO), &a12, &a8, &a4, &a0 );
14813 breakV128to4x64U( mkexpr(vB), &b3, &b2, &b1, &b0 );
14816 assign( z3, binop(Iop_Add64, mkexpr(b3),
14818 binop(Iop_Add64, mkexpr(a15), mkexpr(a14)),
14819 binop(Iop_Add64, mkexpr(a13), mkexpr(a12)))) );
14820 assign( z2, binop(Iop_Add64, mkexpr(b2),
14822 binop(Iop_Add64, mkexpr(a11), mkexpr(a10)),
14823 binop(Iop_Add64, mkexpr(a9), mkexpr(a8)))) );
14824 assign( z1, binop(Iop_Add64, mkexpr(b1),
14826 binop(Iop_Add64, mkexpr(a7), mkexpr(a6)),
14827 binop(Iop_Add64, mkexpr(a5), mkexpr(a4)))) );
14828 assign( z0, binop(Iop_Add64, mkexpr(b0),
14830 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
14831 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
14834 putVReg( vD_addr, mkV128from4x64U( mkexpr(z3), mkexpr(z2),
14835 mkexpr(z1), mkexpr(z0)) );
14844 expand8Sx16( mkexpr(vA), &aEvn, &aOdd ); // (15,13...),(14,12...)
14845 expand16Sx8( mkexpr(aEvn), &aEE, &aEO ); // (15,11...),(13, 9...)
14846 expand16Sx8( mkexpr(aOdd), &aOE, &aOO ); // (14,10...),(12, 8...)
14849 breakV128to4x64S( mkexpr(aEE), &a15, &a11, &a7, &a3 );
14850 breakV128to4x64S( mkexpr(aOE), &a14, &a10, &a6, &a2 );
14851 breakV128to4x64S( mkexpr(aEO), &a13, &a9, &a5, &a1 );
14852 breakV128to4x64S( mkexpr(aOO), &a12, &a8, &a4, &a0 );
14853 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
14856 assign( z3, binop(Iop_Add64, mkexpr(b3),
14858 binop(Iop_Add64, mkexpr(a15), mkexpr(a14)),
14859 binop(Iop_Add64, mkexpr(a13), mkexpr(a12)))) );
14860 assign( z2, binop(Iop_Add64, mkexpr(b2),
14862 binop(Iop_Add64, mkexpr(a11), mkexpr(a10)),
14863 binop(Iop_Add64, mkexpr(a9), mkexpr(a8)))) );
14864 assign( z1, binop(Iop_Add64, mkexpr(b1),
14866 binop(Iop_Add64, mkexpr(a7), mkexpr(a6)),
14867 binop(Iop_Add64, mkexpr(a5), mkexpr(a4)))) );
14868 assign( z0, binop(Iop_Add64, mkexpr(b0),
14870 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
14871 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
14874 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
14875 mkexpr(z1), mkexpr(z0)) );
14882 expand16Sx8( mkexpr(vA), &aEvn, &aOdd ); // (7,5...),(6,4...)
14885 breakV128to4x64S( mkexpr(aEvn), &a7, &a5, &a3, &a1 );
14886 breakV128to4x64S( mkexpr(aOdd), &a6, &a4, &a2, &a0 );
14887 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
14890 assign( z3, binop(Iop_Add64, mkexpr(b3),
14891 binop(Iop_Add64, mkexpr(a7), mkexpr(a6))));
14892 assign( z2, binop(Iop_Add64, mkexpr(b2),
14893 binop(Iop_Add64, mkexpr(a5), mkexpr(a4))));
14894 assign( z1, binop(Iop_Add64, mkexpr(b1),
14895 binop(Iop_Add64, mkexpr(a3), mkexpr(a2))));
14896 assign( z0, binop(Iop_Add64, mkexpr(b0),
14897 binop(Iop_Add64, mkexpr(a1), mkexpr(a0))));
14900 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
14901 mkexpr(z1), mkexpr(z0)) );
14908 breakV128to4x64S( mkexpr(vA), &a3, &a2, &a1, &a0 );
14909 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
14912 assign( z2, binop(Iop_Add64, mkexpr(b2),
14913 binop(Iop_Add64, mkexpr(a3), mkexpr(a2))) );
14914 assign( z0, binop(Iop_Add64, mkexpr(b0),
14915 binop(Iop_Add64, mkexpr(a1), mkexpr(a0))) );
14918 putVReg( vD_addr, mkV128from4x64S( mkU64(0), mkexpr(z2),
14919 mkU64(0), mkexpr(z0)) );
14926 breakV128to4x64S( mkexpr(vA), &a3, &a2, &a1, &a0 );
14927 breakV128to4x64S( mkexpr(vB), &b3, &b2, &b1, &b0 );
14930 assign( z0, binop(Iop_Add64, mkexpr(b0),
14932 binop(Iop_Add64, mkexpr(a3), mkexpr(a2)),
14933 binop(Iop_Add64, mkexpr(a1), mkexpr(a0)))) );
14937 mkU64(0), mkexpr(z0)) );
14972 putVReg( vD_addr, binop(Iop_AndV128, mkexpr(vA), mkexpr(vB)) );
14977 putVReg( vD_addr, binop(Iop_AndV128, mkexpr(vA),
14978 unop(Iop_NotV128, mkexpr(vB))) );
14983 putVReg( vD_addr, binop(Iop_OrV128, mkexpr(vA), mkexpr(vB)) );
14988 putVReg( vD_addr, binop(Iop_XorV128, mkexpr(vA), mkexpr(vB)) );
14994 unop(Iop_NotV128, binop(Iop_OrV128, mkexpr(vA), mkexpr(vB))) );
15032 assign( vD, binop(Iop_CmpEQ8x16, mkexpr(vA), mkexpr(vB)) );
15038 assign( vD, binop(Iop_CmpEQ16x8, mkexpr(vA), mkexpr(vB)) );
15044 assign( vD, binop(Iop_CmpEQ32x4, mkexpr(vA), mkexpr(vB)) );
15050 assign( vD, binop(Iop_CmpGT8Ux16, mkexpr(vA), mkexpr(vB)) );
15056 assign( vD, binop(Iop_CmpGT16Ux8, mkexpr(vA), mkexpr(vB)) );
15062 assign( vD, binop(Iop_CmpGT32Ux4, mkexpr(vA), mkexpr(vB)) );
15068 assign( vD, binop(Iop_CmpGT8Sx16, mkexpr(vA), mkexpr(vB)) );
15074 assign( vD, binop(Iop_CmpGT16Sx8, mkexpr(vA), mkexpr(vB)) );
15080 assign( vD, binop(Iop_CmpGT32Sx4, mkexpr(vA), mkexpr(vB)) );
15088 putVReg( vD_addr, mkexpr(vD) );
15091 set_AV_CR6( mkexpr(vD), True );
15149 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)));
15150 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
15151 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
15152 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
15153 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
15154 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
15155 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
15157 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
15160 mkexpr(aLo), mkexpr(bLo)),
15163 assign( zHi, binop(Iop_Add32x4, mkexpr(cHi),
15166 mkexpr(aHi), mkexpr(bHi)),
15170 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(zHi), mkexpr(zLo)) );
15178 assign(cSigns, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vC)) );
15179 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
15180 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
15181 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(cSigns),mkexpr(vC)));
15182 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
15183 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
15184 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(cSigns),mkexpr(vC)));
15190 assign( zLo, binop(Iop_Add32x4, mkexpr(cLo),
15192 binop(Iop_Add32x4, mkexpr(zKonst),
15194 mkexpr(aLo), mkexpr(bLo))),
15197 mkexpr(cHi),
15199 binop(Iop_Add32x4, mkexpr(zKonst),
15201 mkexpr(aHi), mkexpr(bHi))),
15205 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(zHi), mkexpr(zLo)) );
15211 assign(aLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vA)));
15212 assign(bLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vB)));
15213 assign(cLo, binop(Iop_InterleaveLO16x8, mkexpr(zeros), mkexpr(vC)));
15214 assign(aHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vA)));
15215 assign(bHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vB)));
15216 assign(cHi, binop(Iop_InterleaveHI16x8, mkexpr(zeros), mkexpr(vC)));
15218 binop(Iop_MullEven16Ux8, mkexpr(aLo), mkexpr(bLo)),
15219 mkexpr(cLo)) );
15221 binop(Iop_MullEven16Ux8, mkexpr(aHi), mkexpr(bHi)),
15222 mkexpr(cHi)));
15224 binop(Iop_NarrowBin32to16x8, mkexpr(zHi), mkexpr(zLo)) );
15237 assign( abEvn, MK_Iop_MullOdd8Ux16( mkexpr(vA), mkexpr(vB) ));
15238 assign( abOdd, binop(Iop_MullEven8Ux16, mkexpr(vA), mkexpr(vB)) );
15241 expand16Ux8( mkexpr(abEvn), &abEE, &abEO );
15242 expand16Ux8( mkexpr(abOdd), &abOE, &abOO );
15245 binop(Iop_Add32x4, mkexpr(vC),
15247 binop(Iop_Add32x4, mkexpr(abEE), mkexpr(abEO)),
15248 binop(Iop_Add32x4, mkexpr(abOE), mkexpr(abOO)))) );
15263 expand8Sx16( mkexpr(vA), &aEvn, &aOdd );
15264 expand8Ux16( mkexpr(vB), &bEvn, &bOdd );
15267 assign( abEE, MK_Iop_MullOdd16Sx8( mkexpr(aEvn), mkexpr(bEvn) ));
15268 assign( abEO, binop(Iop_MullEven16Sx8, mkexpr(aEvn), mkexpr(bEvn)) );
15269 assign( abOE, MK_Iop_MullOdd16Sx8( mkexpr(aOdd), mkexpr(bOdd) ));
15270 assign( abOO, binop(Iop_MullEven16Sx8, mkexpr(aOdd), mkexpr(bOdd)) );
15274 binop(Iop_QAdd32Sx4, mkexpr(vC),
15276 binop(Iop_QAdd32Sx4, mkexpr(abEE), mkexpr(abEO)),
15277 binop(Iop_QAdd32Sx4, mkexpr(abOE), mkexpr(abOO)))) );
15283 assign( abEvn, MK_Iop_MullOdd16Ux8( mkexpr(vA), mkexpr(vB) ));
15284 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
15286 binop(Iop_Add32x4, mkexpr(vC),
15287 binop(Iop_Add32x4, mkexpr(abEvn), mkexpr(abOdd))) );
15294 assign( abEvn, MK_Iop_MullOdd16Ux8(mkexpr(vA), mkexpr(vB) ));
15295 assign( abOdd, binop(Iop_MullEven16Ux8, mkexpr(vA), mkexpr(vB)) );
15298 breakV128to4x64U( mkexpr(abEvn), &ab7, &ab5, &ab3, &ab1 );
15299 breakV128to4x64U( mkexpr(abOdd), &ab6, &ab4, &ab2, &ab0 );
15300 breakV128to4x64U( mkexpr(vC), &c3, &c2, &c1, &c0 );
15303 assign( z3, binop(Iop_Add64, mkexpr(c3),
15304 binop(Iop_Add64, mkexpr(ab7), mkexpr(ab6))));
15305 assign( z2, binop(Iop_Add64, mkexpr(c2),
15306 binop(Iop_Add64, mkexpr(ab5), mkexpr(ab4))));
15307 assign( z1, binop(Iop_Add64, mkexpr(c1),
15308 binop(Iop_Add64, mkexpr(ab3), mkexpr(ab2))));
15309 assign( z0, binop(Iop_Add64, mkexpr(c0),
15310 binop(Iop_Add64, mkexpr(ab1), mkexpr(ab0))));
15313 putVReg( vD_addr, mkV128from4x64U( mkexpr(z3), mkexpr(z2),
15314 mkexpr(z1), mkexpr(z0)) );
15321 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
15322 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
15324 binop(Iop_Add32x4, mkexpr(vC),
15325 binop(Iop_Add32x4, mkexpr(abOdd), mkexpr(abEvn))) );
15332 assign( abEvn, MK_Iop_MullOdd16Sx8( mkexpr(vA), mkexpr(vB) ));
15333 assign( abOdd, binop(Iop_MullEven16Sx8, mkexpr(vA), mkexpr(vB)) );
15336 breakV128to4x64S( mkexpr(abEvn), &ab7, &ab5, &ab3, &ab1 );
15337 breakV128to4x64S( mkexpr(abOdd), &ab6, &ab4, &ab2, &ab0 );
15338 breakV128to4x64S( mkexpr(vC), &c3, &c2, &c1, &c0 );
15341 assign( z3, binop(Iop_Add64, mkexpr(c3),
15342 binop(Iop_Add64, mkexpr(ab7), mkexpr(ab6))));
15343 assign( z2, binop(Iop_Add64, mkexpr(c2),
15344 binop(Iop_Add64, mkexpr(ab5), mkexpr(ab4))));
15345 assign( z1, binop(Iop_Add64, mkexpr(c1),
15346 binop(Iop_Add64, mkexpr(ab3), mkexpr(ab2))));
15347 assign( z0, binop(Iop_Add64, mkexpr(c0),
15348 binop(Iop_Add64, mkexpr(ab1), mkexpr(ab0))));
15351 putVReg( vD_addr, mkV128from4x64S( mkexpr(z3), mkexpr(z2),
15352 mkexpr(z1), mkexpr(z0)) );
15388 putVReg( vD_addr, binop(Iop_Rol8x16, mkexpr(vA), mkexpr(vB)) );
15393 putVReg( vD_addr, binop(Iop_Rol16x8, mkexpr(vA), mkexpr(vB)) );
15398 putVReg( vD_addr, binop(Iop_Rol32x4, mkexpr(vA), mkexpr(vB)) );
15405 putVReg( vD_addr, binop(Iop_Shl8x16, mkexpr(vA), mkexpr(vB)) );
15410 putVReg( vD_addr, binop(Iop_Shl16x8, mkexpr(vA), mkexpr(vB)) );
15415 putVReg( vD_addr, binop(Iop_Shl32x4, mkexpr(vA), mkexpr(vB)) );
15423 unop(Iop_V128to32, mkexpr(vB)))) );
15425 binop(Iop_ShlV128, mkexpr(vA), mkexpr(sh)) );
15433 unop(Iop_V128to32, mkexpr(vB)))) );
15435 binop(Iop_ShlV128, mkexpr(vA), mkexpr(sh)) );
15443 putVReg( vD_addr, binop(Iop_Shr8x16, mkexpr(vA), mkexpr(vB)) );
15448 putVReg( vD_addr, binop(Iop_Shr16x8, mkexpr(vA), mkexpr(vB)) );
15453 putVReg( vD_addr, binop(Iop_Shr32x4, mkexpr(vA), mkexpr(vB)) );
15461 unop(Iop_V128to32, mkexpr(vB)))) );
15463 binop(Iop_ShrV128, mkexpr(vA), mkexpr(sh)) );
15468 putVReg( vD_addr, binop(Iop_Sar8x16, mkexpr(vA), mkexpr(vB)) );
15473 putVReg( vD_addr, binop(Iop_Sar16x8, mkexpr(vA), mkexpr(vB)) );
15478 putVReg( vD_addr, binop(Iop_Sar32x4, mkexpr(vA), mkexpr(vB)) );
15486 unop(Iop_V128to32, mkexpr(vB)))) );
15488 binop(Iop_ShrV128, mkexpr(vA), mkexpr(sh)) );
15534 binop(Iop_AndV128, mkexpr(vA), unop(Iop_NotV128, mkexpr(vC))),
15535 binop(Iop_AndV128, mkexpr(vB), mkexpr(vC))) );
15550 binop(Iop_AndV128, mkexpr(vC),
15553 binop(Iop_Perm8x16, mkexpr(vA), mkexpr(vC_andF)) );
15555 binop(Iop_Perm8x16, mkexpr(vB), mkexpr(vC_andF)) );
15558 binop(Iop_ShlN8x16, mkexpr(vC), mkU8(3)),
15562 binop(Iop_AndV128, mkexpr(a_perm),
15563 unop(Iop_NotV128, mkexpr(mask))),
15564 binop(Iop_AndV128, mkexpr(b_perm),
15565 mkexpr(mask))) );
15576 putVReg( vD_addr, mkexpr(vA) );
15580 binop(Iop_ShlV128, mkexpr(vA), mkU8(SHB_uimm4*8)),
15581 binop(Iop_ShrV128, mkexpr(vB), mkU8((16-SHB_uimm4)*8))) );
15595 binop(Iop_InterleaveHI8x16, mkexpr(vA), mkexpr(vB)) );
15601 binop(Iop_InterleaveHI16x8, mkexpr(vA), mkexpr(vB)) );
15607 binop(Iop_InterleaveHI32x4, mkexpr(vA), mkexpr(vB)) );
15613 binop(Iop_InterleaveLO8x16, mkexpr(vA), mkexpr(vB)) );
15619 binop(Iop_InterleaveLO16x8, mkexpr(vA), mkexpr(vB)) );
15625 binop(Iop_InterleaveLO32x4, mkexpr(vA), mkexpr(vB)) );
15636 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm))))) );
15644 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm))))) );
15653 binop(Iop_ShrV128, mkexpr(vB), mkU8(sh_uimm)))) );
15709 binop(Iop_NarrowBin16to8x16, mkexpr(vA), mkexpr(vB)) );
15715 binop(Iop_NarrowBin32to16x8, mkexpr(vA), mkexpr(vB)) );
15721 binop(Iop_QNarrowBin16Uto8Ux16, mkexpr(vA), mkexpr(vB)) );
15728 binop(Iop_QNarrowBin32Uto16Ux8, mkexpr(vA), mkexpr(vB)) );
15739 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
15742 mkexpr(vA), mkU8(15)))) );
15743 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
15746 mkexpr(vB), mkU8(15)))) );
15748 mkexpr(vA_tmp), mkexpr(vB_tmp)) );
15759 assign( vA_tmp, binop(Iop_AndV128, mkexpr(vA),
15762 mkexpr(vA), mkU8(31)))) );
15763 assign( vB_tmp, binop(Iop_AndV128, mkexpr(vB),
15766 mkexpr(vB), mkU8(31)))) );
15768 mkexpr(vA_tmp), mkexpr(vB_tmp)) );
15775 binop(Iop_QNarrowBin16Sto8Sx16, mkexpr(vA), mkexpr(vB)) );
15782 binop(Iop_QNarrowBin32Sto16Sx8, mkexpr(vA), mkexpr(vB)) );
15799 binop(Iop_ShrN32x4, mkexpr(vA), mkU8(19)),
15802 binop(Iop_ShrN16x8, mkexpr(vA), mkU8(11)),
15805 binop(Iop_ShlN16x8, mkexpr(vA), mkU8(8)),
15807 assign( a_tmp, binop(Iop_OrV128, mkexpr(a1),
15808 binop(Iop_OrV128, mkexpr(a2), mkexpr(a3))) );
15811 binop(Iop_ShrN32x4, mkexpr(vB), mkU8(19)),
15814 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(11)),
15817 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(8)),
15819 assign( b_tmp, binop(Iop_OrV128, mkexpr(b1),
15820 binop(Iop_OrV128, mkexpr(b2), mkexpr(b3))) );
15823 mkexpr(a_tmp), mkexpr(b_tmp)) );
15845 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
15847 binop(Iop_InterleaveHI8x16, mkexpr(signs), mkexpr(vB)) );
15852 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
15854 binop(Iop_InterleaveHI16x8, mkexpr(signs), mkexpr(vB)) );
15859 assign( signs, binop(Iop_CmpGT8Sx16, mkexpr(zeros), mkexpr(vB)) );
15861 binop(Iop_InterleaveLO8x16, mkexpr(signs), mkexpr(vB)) );
15866 assign( signs, binop(Iop_CmpGT16Sx8, mkexpr(zeros), mkexpr(vB)) );
15868 binop(Iop_InterleaveLO16x8, mkexpr(signs), mkexpr(vB)) );
15882 binop(Iop_SarN16x8, mkexpr(vB), mkU8(15)),
15885 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(1)),
15887 assign( z01, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
15888 binop(Iop_OrV128, mkexpr(z0), mkexpr(z1))) );
15891 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(5)),
15895 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(11)),
15897 assign( z23, binop(Iop_InterleaveHI16x8, mkexpr(zeros),
15898 binop(Iop_OrV128, mkexpr(z2), mkexpr(z3))) );
15901 binop(Iop_ShlN32x4, mkexpr(z01), mkU8(16)),
15902 mkexpr(z23)) );
15915 binop(Iop_SarN16x8, mkexpr(vB), mkU8(15)),
15918 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(1)),
15920 assign( z01, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
15921 binop(Iop_OrV128, mkexpr(z0), mkexpr(z1))) );
15924 binop(Iop_ShrN16x8, mkexpr(vB), mkU8(5)),
15928 binop(Iop_ShlN16x8, mkexpr(vB), mkU8(11)),
15930 assign( z23, binop(Iop_InterleaveLO16x8, mkexpr(zeros),
15931 binop(Iop_OrV128, mkexpr(z2), mkexpr(z3))) );
15934 binop(Iop_ShlN32x4, mkexpr(z01), mkU8(16)),
15935 mkexpr(z23)) );
15977 binop(Iop_Add32Fx4, mkexpr(vB),
15978 binop(Iop_Mul32Fx4, mkexpr(vA), mkexpr(vC))) );
15986 mkexpr(vB),
15987 binop(Iop_Mul32Fx4, mkexpr(vA), mkexpr(vC))) );
15999 putVReg( vD_addr, binop(Iop_Add32Fx4, mkexpr(vA), mkexpr(vB)) );
16004 putVReg( vD_addr, binop(Iop_Sub32Fx4, mkexpr(vA), mkexpr(vB)) );
16009 putVReg( vD_addr, binop(Iop_Max32Fx4, mkexpr(vA), mkexpr(vB)) );
16014 putVReg( vD_addr, binop(Iop_Min32Fx4, mkexpr(vA), mkexpr(vB)) );
16030 putVReg( vD_addr, unop(Iop_Recip32Fx4, mkexpr(vB)) );
16035 putVReg( vD_addr, unop(Iop_RSqrt32Fx4, mkexpr(vB)) );
16085 assign( vD, binop(Iop_CmpEQ32Fx4, mkexpr(vA), mkexpr(vB)) );
16091 assign( vD, binop(Iop_CmpGE32Fx4, mkexpr(vA), mkexpr(vB)) );
16097 assign( vD, binop(Iop_CmpGT32Fx4, mkexpr(vA), mkexpr(vB)) );
16118 binop(Iop_CmpLE32Fx4, mkexpr(vA), mkexpr(vB))) );
16120 binop(Iop_CmpGE32Fx4, mkexpr(vA),
16121 binop(Iop_Sub32Fx4, mkexpr(zeros),
16122 mkexpr(vB)))) );
16127 binop(Iop_AndV128, mkexpr(gt),
16129 binop(Iop_AndV128, mkexpr(lt),
16140 putVReg( vD_addr, mkexpr(vD) );
16143 set_AV_CR6( mkexpr(vD), !cmp_bounds );
16184 unop(Iop_I32UtoFx4, mkexpr(vB)),
16185 mkexpr(vInvScale)) );
16192 unop(Iop_I32StoFx4, mkexpr(vB)),
16193 mkexpr(vInvScale)) );
16200 binop(Iop_Mul32Fx4, mkexpr(vB), mkexpr(vScale))) );
16207 binop(Iop_Mul32Fx4, mkexpr(vB), mkexpr(vScale))) );
16222 putVReg( vD_addr, unop(Iop_RoundF32x4_RN, mkexpr(vB)) );
16227 putVReg( vD_addr, unop(Iop_RoundF32x4_RZ, mkexpr(vB)) );
16232 putVReg( vD_addr, unop(Iop_RoundF32x4_RP, mkexpr(vB)) );
16237 putVReg( vD_addr, unop(Iop_RoundF32x4_RM, mkexpr(vB)) );
17811 // assign(n1, mkexpr(arg));
17812 // assign(n2, binop(Iop_Or32, mkexpr(n1), binop(Iop_Shr32, mkexpr(n1), mkU8(1))));
17813 // assign(n3, binop(Iop_Or32, mkexpr(n2), binop(Iop_Shr32, mkexpr(n2), mkU8(2))));
17814 // assign(n4, binop(Iop_Or32, mkexpr(n3), binop(Iop_Shr32, mkexpr(n3), mkU8(4))));
17815 // assign(n5, binop(Iop_Or32, mkexpr(n4), binop(Iop_Shr32, mkexpr(n4), mkU8(8))));
17816 // assign(n6, binop(Iop_Or32, mkexpr(n5), binop(Iop_Shr32, mkexpr(n5), mkU8(16))));
17821 // assign(n7, unop(Iop_Not32, mkexpr(n6)));
17835 // mkexpr(n7),
17837 // binop(Iop_Shr32, mkexpr(n7), mkU8(1)),
17841 // binop(Iop_And32, mkexpr(n8), mkU32(0x33333333)),
17843 // binop(Iop_Shr32, mkexpr(n8), mkU8(2)),
17848 // mkexpr(n9),
17849 // binop(Iop_Shr32, mkexpr(n9), mkU8(4))),
17853 // mkexpr(n10),
17854 // binop(Iop_Shr32, mkexpr(n10), mkU8(8))));
17857 // mkexpr(n11),
17858 // binop(Iop_Shr32, mkexpr(n11), mkU8(16))));
17860 // binop(Iop_And32, mkexpr(n12), mkU32(0x3F));
