openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

target-ppc: rename CRF_* defines as CRF_*_BIT 

Add _BIT to CRF_[GT,LT,EQ_SO] and introduce CRF_[GT,LT,EQ,SO] for usage
without shifts in the code. This would simplify the code.

Signed-off-by: Nikunj A Dadhania <nikunj@linux.vnet.ibm.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
This commit is contained in:
Nikunj A Dadhania 2016-11-23 17:07:11 +05:30 committed by David Gibson
parent 985e3023f7
commit efa7319619
3 changed files with 35 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
target/ppc/cpu.h
View File

@ -1301,14 +1301,19 @@ static inline int cpu_mmu_index (CPUPPCState *env, bool ifetch)
/*****************************************************************************/ /*****************************************************************************/
/* CRF definitions */ /* CRF definitions */
#define CRF_LT 3 #define CRF_LT_BIT 3
#define CRF_GT 2 #define CRF_GT_BIT 2
#define CRF_EQ 1 #define CRF_EQ_BIT 1
#define CRF_SO 0 #define CRF_SO_BIT 0
#define CRF_CH (1 << CRF_LT) #define CRF_LT (1 << CRF_LT_BIT)
#define CRF_CL (1 << CRF_GT) #define CRF_GT (1 << CRF_GT_BIT)
#define CRF_CH_OR_CL (1 << CRF_EQ) #define CRF_EQ (1 << CRF_EQ_BIT)
#define CRF_CH_AND_CL (1 << CRF_SO) #define CRF_SO (1 << CRF_SO_BIT)
/* For SPE extensions */
#define CRF_CH (1 << CRF_LT_BIT)
#define CRF_CL (1 << CRF_GT_BIT)
#define CRF_CH_OR_CL (1 << CRF_EQ_BIT)
#define CRF_CH_AND_CL (1 << CRF_SO_BIT)
/* XER definitions */ /* XER definitions */
#define XER_SO 31 #define XER_SO 31

30
target/ppc/int_helper.c
View File

@ -157,7 +157,7 @@ uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe)
uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb)
{ {
return hasvalue(rb, ra) ? 1 << CRF_GT : 0; return hasvalue(rb, ra) ? CRF_GT : 0;
} }
#undef pattern #undef pattern
@ -2531,9 +2531,9 @@ static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n)
static int bcd_cmp_zero(ppc_avr_t *bcd) static int bcd_cmp_zero(ppc_avr_t *bcd)
{ {
if (bcd->u64[HI_IDX] == 0 && (bcd->u64[LO_IDX] >> 4) == 0) { if (bcd->u64[HI_IDX] == 0 && (bcd->u64[LO_IDX] >> 4) == 0) {
return 1 << CRF_EQ; return CRF_EQ;
} else { } else {
return (bcd_get_sgn(bcd) == 1) ? 1 << CRF_GT : 1 << CRF_LT; return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT;
} }
} }
@ -2645,25 +2645,25 @@ uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
if (sgna == sgnb) { if (sgna == sgnb) {
result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
zero = bcd_add_mag(&result, a, b, &invalid, &overflow); zero = bcd_add_mag(&result, a, b, &invalid, &overflow);
cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT; cr = (sgna > 0) ? CRF_GT : CRF_LT;
} else if (bcd_cmp_mag(a, b) > 0) { } else if (bcd_cmp_mag(a, b) > 0) {
result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
zero = bcd_sub_mag(&result, a, b, &invalid, &overflow); zero = bcd_sub_mag(&result, a, b, &invalid, &overflow);
cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT; cr = (sgna > 0) ? CRF_GT : CRF_LT;
} else { } else {
result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps); result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps);
zero = bcd_sub_mag(&result, b, a, &invalid, &overflow); zero = bcd_sub_mag(&result, b, a, &invalid, &overflow);
cr = (sgnb > 0) ? 1 << CRF_GT : 1 << CRF_LT; cr = (sgnb > 0) ? CRF_GT : CRF_LT;
} }
} }
if (unlikely(invalid)) { if (unlikely(invalid)) {
result.u64[HI_IDX] = result.u64[LO_IDX] = -1; result.u64[HI_IDX] = result.u64[LO_IDX] = -1;
cr = 1 << CRF_SO; cr = CRF_SO;
} else if (overflow) { } else if (overflow) {
cr |= 1 << CRF_SO; cr |= CRF_SO;
} else if (zero) { } else if (zero) {
cr = 1 << CRF_EQ; cr = CRF_EQ;
} }
*r = result; *r = result;
@ -2713,7 +2713,7 @@ uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
cr = bcd_cmp_zero(&ret); cr = bcd_cmp_zero(&ret);
if (unlikely(invalid)) { if (unlikely(invalid)) {
cr = 1 << CRF_SO; cr = CRF_SO;
} }
*r = ret; *r = ret;
@ -2743,11 +2743,11 @@ uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
cr = bcd_cmp_zero(b); cr = bcd_cmp_zero(b);
if (ox_flag) { if (ox_flag) {
cr |= 1 << CRF_SO; cr |= CRF_SO;
} }
if (unlikely(invalid)) { if (unlikely(invalid)) {
cr = 1 << CRF_SO; cr = CRF_SO;
} }
*r = ret; *r = ret;
@ -2791,7 +2791,7 @@ uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
cr = bcd_cmp_zero(&ret); cr = bcd_cmp_zero(&ret);
if (unlikely(invalid)) { if (unlikely(invalid)) {
cr = 1 << CRF_SO; cr = CRF_SO;
} }
*r = ret; *r = ret;
@ -2830,11 +2830,11 @@ uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
cr = bcd_cmp_zero(b); cr = bcd_cmp_zero(b);
if (ox_flag) { if (ox_flag) {
cr |= 1 << CRF_SO; cr |= CRF_SO;
} }
if (unlikely(invalid)) { if (unlikely(invalid)) {
cr = 1 << CRF_SO; cr = CRF_SO;
} }
*r = ret; *r = ret;

14
target/ppc/translate.c
View File

@ -612,17 +612,17 @@ static inline void gen_op_cmp(TCGv arg0, TCGv arg1, int s, int crf)
tcg_gen_setcond_tl((s ? TCG_COND_LT: TCG_COND_LTU), t0, arg0, arg1); tcg_gen_setcond_tl((s ? TCG_COND_LT: TCG_COND_LTU), t0, arg0, arg1);
tcg_gen_trunc_tl_i32(t1, t0); tcg_gen_trunc_tl_i32(t1, t0);
tcg_gen_shli_i32(t1, t1, CRF_LT); tcg_gen_shli_i32(t1, t1, CRF_LT_BIT);
tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1); tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1);
tcg_gen_setcond_tl((s ? TCG_COND_GT: TCG_COND_GTU), t0, arg0, arg1); tcg_gen_setcond_tl((s ? TCG_COND_GT: TCG_COND_GTU), t0, arg0, arg1);
tcg_gen_trunc_tl_i32(t1, t0); tcg_gen_trunc_tl_i32(t1, t0);
tcg_gen_shli_i32(t1, t1, CRF_GT); tcg_gen_shli_i32(t1, t1, CRF_GT_BIT);
tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1); tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1);
tcg_gen_setcond_tl(TCG_COND_EQ, t0, arg0, arg1); tcg_gen_setcond_tl(TCG_COND_EQ, t0, arg0, arg1);
tcg_gen_trunc_tl_i32(t1, t0); tcg_gen_trunc_tl_i32(t1, t0);
tcg_gen_shli_i32(t1, t1, CRF_EQ); tcg_gen_shli_i32(t1, t1, CRF_EQ_BIT);
tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1); tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t1);
tcg_temp_free(t0); tcg_temp_free(t0);
@ -748,7 +748,7 @@ static void gen_cmprb(DisasContext *ctx)
tcg_gen_and_i32(src2lo, src2lo, src2hi); tcg_gen_and_i32(src2lo, src2lo, src2hi);
tcg_gen_or_i32(crf, crf, src2lo); tcg_gen_or_i32(crf, crf, src2lo);
} }
tcg_gen_shli_i32(crf, crf, CRF_GT); tcg_gen_shli_i32(crf, crf, CRF_GT_BIT);
tcg_temp_free_i32(src1); tcg_temp_free_i32(src1);
tcg_temp_free_i32(src2); tcg_temp_free_i32(src2);
tcg_temp_free_i32(src2lo); tcg_temp_free_i32(src2lo);
@ -2997,7 +2997,7 @@ static void gen_conditional_store(DisasContext *ctx, TCGv EA,
tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so); tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so);
l1 = gen_new_label(); l1 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, l1); tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, l1);
tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ); tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], CRF_EQ);
tcg_gen_qemu_st_tl(cpu_gpr[reg], EA, ctx->mem_idx, memop); tcg_gen_qemu_st_tl(cpu_gpr[reg], EA, ctx->mem_idx, memop);
gen_set_label(l1); gen_set_label(l1);
tcg_gen_movi_tl(cpu_reserve, -1); tcg_gen_movi_tl(cpu_reserve, -1);
@ -3091,7 +3091,7 @@ static void gen_stqcx_(DisasContext *ctx)
tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so); tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so);
l1 = gen_new_label(); l1 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, l1); tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, l1);
tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ); tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], CRF_EQ);
if (unlikely(ctx->le_mode)) { if (unlikely(ctx->le_mode)) {
gpr1 = cpu_gpr[reg + 1]; gpr1 = cpu_gpr[reg + 1];
@ -4272,7 +4272,7 @@ static void gen_slbfee_(DisasContext *ctx)
l2 = gen_new_label(); l2 = gen_new_label();
tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so); tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so);
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rS(ctx->opcode)], -1, l1); tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rS(ctx->opcode)], -1, l1);
tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ); tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], CRF_EQ);
tcg_gen_br(l2); tcg_gen_br(l2);
gen_set_label(l1); gen_set_label(l1);
tcg_gen_movi_tl(cpu_gpr[rS(ctx->opcode)], 0); tcg_gen_movi_tl(cpu_gpr[rS(ctx->opcode)], 0);