OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

target: e2k: Reorg br.

This commit is contained in:
Denis Drakhnia 2020-11-26 20:25:43 +02:00 committed by Denis Drakhnia
parent 4d16d006d5
commit dd3aa7283a
5 changed files with 99 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
target/e2k/cpu.c
View File

@ -53,9 +53,11 @@ static void e2k_cpu_reset(DeviceState *dev)
env->wd_base = 0;
env->wd_size = 8;
env->wd_psize = 8;
env->boff = 8;
env->bsize = 8;
env->bcur = 0;
env->bn.base = 8;
env->bn.size = 8;
env->bn.cur = 0;
/* Based predicate window must not be zero. */
env->bp.size = 1;
env->idr = 0x3a207; // mimic 8c
}
@ -106,19 +108,16 @@ static inline void cpu_dump_state_wd(CPUE2KState *env, FILE *f, int flags)
static inline void cpu_dump_state_br(CPUE2KState *env, FILE *f, int flags)
{
uint32_t br = GET_FIELD(env->cr1_hi, CR1_HI_BR_OFF, CR1_HI_BR_LEN);
int rbs = GET_FIELD(br, BR_RBS_OFF, BR_RBS_LEN);
int rsz = GET_FIELD(br, BR_RSZ_OFF, BR_RSZ_LEN);
int rcur = GET_FIELD(br, BR_RCUR_OFF, BR_RCUR_LEN);
int psz = GET_FIELD(br, BR_PSZ_OFF, BR_PSZ_LEN);
int pcur = GET_FIELD(br, BR_PCUR_OFF, BR_PCUR_LEN);
uint32_t br = e2k_state_br(env);
E2KBnState *bn = &env->bn;
E2KBpState *bp = &env->bp;
qemu_fprintf(f, "br 0x%x\n", br);
qemu_fprintf(f, " rbs %d\n", rbs);
qemu_fprintf(f, " rsz %d\n", rsz);
qemu_fprintf(f, " rcur %d\n", rcur);
qemu_fprintf(f, " psz %d\n", psz);
qemu_fprintf(f, " pcur %d\n", pcur);
qemu_fprintf(f, " rbs %d\n", bn->base / 2);
qemu_fprintf(f, " rsz %d\n", bn->size / 2 - 1);
qemu_fprintf(f, " rcur %d\n", bn->cur / 2);
qemu_fprintf(f, " psz %d\n", bp->size);
qemu_fprintf(f, " pcur %d\n", bp->cur);
}
void e2k_cpu_dump_state(CPUState *cs, FILE *f, int flags)

86
target/e2k/cpu.h
View File

@ -229,6 +229,31 @@ struct e2k_def_t {
uint32_t isa_version;
};
typedef struct {
uint32_t base;
uint32_t size;
uint32_t cur;
} E2KBnState;
typedef struct {
uint32_t size;
uint32_t cur;
} E2KBpState;
typedef struct {
uint32_t br;
uint32_t cuir;
uint32_t ussz;
uint16_t tr;
uint8_t ein;
bool ss;
bool wfx;
uint8_t wpsz;
uint8_t wbs;
uint8_t psr;
bool wdbl;
} E2KControlReg1State;
typedef struct {
void *base;
uint32_t index;
@ -237,6 +262,13 @@ typedef struct {
bool is_writable;
} E2KDescState, E2KPsState, E2KPcsState;
typedef struct {
int16_t index;
uint16_t fx_index;
uint16_t t_index;
bool fx;
} E2KPshtpState;
typedef struct CPUArchState {
/* register file */
uint64_t gregs[GREGS_SIZE]; /* global registers */
@ -246,22 +278,19 @@ typedef struct CPUArchState {
/* Procedure chain info = cr0_lo, cr0_hi, cr1_lo, cr1_hi */
E2KPcsState pcsp;
uint64_t pcshtp;
uint32_t br;
/* Procedure stack pointer (for regs) */
E2KPsState psp;
uint64_t pshtp;
E2KPshtpState pshtp;
E2KBnState bn;
E2KBpState bp;
uint64_t lsr; /* loop status register */
uint32_t wd_base;
uint32_t wd_size;
uint32_t wd_psize;
uint32_t boff; /* holds rbs * 2 */
uint32_t bsize; /* holds rsz * 2 + 2 */
uint32_t bcur; /* holds rcur * 2 */
uint32_t psize; /* holds psz */
uint32_t pcur; /* holds pcur */
uint64_t usd_lo;
uint64_t usd_hi;
@ -368,12 +397,53 @@ static inline uint64_t e2k_state_desc_hi(E2KDescState *env)
return hi;
}
#define e2k_state_pcsp_lo(env) e2k_state_desc_lo(&(env)->pcsp)
#define e2k_state_pcsp_hi(env) e2k_state_desc_hi(&(env)->pcsp)
#define e2k_state_psp_lo(env) e2k_state_desc_lo(&(env)->psp)
#define e2k_state_psp_hi(env) e2k_state_desc_hi(&(env)->psp)
static inline uint64_t e2k_state_pshtp(CPUE2KState *env)
{
E2KPshtpState *s = &env->pshtp;
uint64_t ret = 0;
ret = deposit64(ret, PSHTP_IND_OFF, PSHTP_IND_LEN, s->index);
ret = deposit64(ret, PSHTP_FXIND_OFF, PSHTP_FXIND_LEN, s->fx_index);
ret = deposit64(ret, PSHTP_TIND_OFF, PSHTP_TIND_LEN, s->t_index);
ret = deposit64(ret, PSHTP_FX_OFF, 1, s->fx);
return ret;
}
static inline uint32_t e2k_state_br(CPUE2KState *env)
{
E2KBnState *bn = &env->bn;
E2KBpState *bp = &env->bp;
uint32_t ret = 0;
ret = deposit32(ret, BR_RBS_OFF, BR_RBS_LEN, bn->base / 2);
ret = deposit32(ret, BR_RSZ_OFF, BR_RSZ_LEN, bn->size / 2 - 1);
ret = deposit32(ret, BR_RCUR_OFF, BR_RCUR_LEN, bn->cur / 2);
ret = deposit32(ret, BR_PSZ_OFF, BR_PSZ_LEN, bp->size);
ret = deposit32(ret, BR_PCUR_OFF, BR_PCUR_LEN, bp->cur);
return ret;
}
static inline void e2k_state_br_set(CPUE2KState *env, uint32_t br)
{
E2KBnState *bn = &env->bn;
E2KBpState *bp = &env->bp;
bn->base = extract32(br, BR_RBS_OFF, BR_RBS_LEN) * 2;
bn->size = extract32(br, BR_RSZ_OFF, BR_RSZ_LEN) * 2 + 2;
bn->cur = extract32(br, BR_RCUR_OFF, BR_RCUR_LEN) * 2;
bp->size = extract32(br, BR_PSZ_OFF, BR_PSZ_LEN);
bp->cur = extract32(br, BR_PCUR_OFF, BR_PCUR_LEN);
}
static inline int e2k_state_cr1_wbs_get(CPUE2KState *env)
{
return GET_FIELD(env->cr1_lo, CR1_LO_WBS_OFF, CR1_LO_WBS_LEN);

2
target/e2k/gdbstub.c
View File

@ -59,7 +59,7 @@ int e2k_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
case 48: return gdb_get_reg64(mem_buf, env->usd_hi); // usd_hi
case 49: return gdb_get_reg64(mem_buf, e2k_state_psp_lo(env)); // psp_lo
case 50: return gdb_get_reg64(mem_buf, e2k_state_psp_hi(env)); // psp_hi
case 51: return gdb_get_reg64(mem_buf, env->pshtp); // pshtp
case 51: return gdb_get_reg64(mem_buf, e2k_state_pshtp(env)); // pshtp
case 52: return gdb_get_reg64(mem_buf, env->cr0_lo); // cr0_lo
case 53: return gdb_get_reg64(mem_buf, env->cr0_hi); // cr0_hi
case 54: return gdb_get_reg64(mem_buf, env->cr1_lo); // cr1_lo

38
target/e2k/helper.c
View File

@ -16,39 +16,6 @@ static inline void reset_ctprs(CPUE2KState *env)
}
}
static inline void save_br_state(CPUE2KState *env)
{
int rbs, rsz, rcur;
rbs = env->boff / 2;
rsz = (env->bsize - 2) / 2;
rcur = env->bcur / 2;
env->br = SET_FIELD(env->br, rbs, BR_RBS_OFF, BR_RBS_LEN);
env->br = SET_FIELD(env->br, rsz, BR_RSZ_OFF, BR_RSZ_LEN);
env->br = SET_FIELD(env->br, rcur, BR_RCUR_OFF, BR_RCUR_LEN);
env->br = SET_FIELD(env->br, env->psize, BR_PSZ_OFF, BR_PSZ_LEN);
env->br = SET_FIELD(env->br, env->pcur, BR_PCUR_OFF, BR_PCUR_LEN);
e2k_state_cr1_br_set(env, env->br);
}
static inline void restore_br_state(CPUE2KState *env)
{
int rbs, rsz, rcur;
env->br = e2k_state_cr1_br_get(env);
rbs = GET_FIELD(env->br, BR_RBS_OFF, BR_RBS_LEN);
rsz = GET_FIELD(env->br, BR_RSZ_OFF, BR_RSZ_LEN);
rcur = GET_FIELD(env->br, BR_RCUR_OFF, BR_RCUR_LEN);
env->boff = rbs * 2;
env->bsize = rsz * 2 + 2;
env->bcur = rcur * 2;
env->psize = GET_FIELD(env->br, BR_PSZ_OFF, BR_PSZ_LEN);
env->pcur = GET_FIELD(env->br, BR_PCUR_OFF, BR_PCUR_LEN);
}
static void pcs_push(CPUE2KState *env, int wbs)
{
size_t size = sizeof(env->proc_chain);
@ -58,7 +25,7 @@ static void pcs_push(CPUE2KState *env, int wbs)
return;
}
save_br_state(env);
e2k_state_cr1_br_set(env, e2k_state_br(env));
e2k_state_cr1_wpsz_set(env, env->wd_psize / 2);
memcpy(env->pcsp.base + env->pcsp.index, env->proc_chain, size);
e2k_state_cr1_wbs_set(env, wbs);
@ -78,7 +45,7 @@ static void pcs_pop(CPUE2KState *env)
env->pcsp.index -= size;
memcpy(env->proc_chain, env->pcsp.base + env->pcsp.index, size);
env->wd_psize = e2k_state_cr1_wpsz_get(env) * 2;
restore_br_state(env);
e2k_state_br_set(env, e2k_state_cr1_br_get(env));
}
static void ps_push_nfx(CPUE2KState *env, unsigned int base, size_t len)
@ -229,7 +196,6 @@ target_ulong helper_call(CPUE2KState *env, uint64_t ctpr,
void helper_raise_exception(CPUE2KState *env, int tt)
{
CPUState *cs = env_cpu(env);
save_br_state(env);
cs->exception_index = tt;
cpu_loop_exit(cs);
}

10
target/e2k/translate.c
View File

@ -503,11 +503,11 @@ void e2k_tcg_initialize(void) {
static const struct { TCGv_i32 *ptr; int off; const char *name; } r32[] = {
{ &e2k_cs.wd_base, offsetof(CPUE2KState, wd_base), "woff" },
{ &e2k_cs.wd_size, offsetof(CPUE2KState, wd_size), "wsize" },
{ &e2k_cs.boff, offsetof(CPUE2KState, boff), "boff" },
{ &e2k_cs.bsize, offsetof(CPUE2KState, bsize), "bsize" },
{ &e2k_cs.bcur, offsetof(CPUE2KState, bcur), "bcur" },
{ &e2k_cs.psize, offsetof(CPUE2KState, psize), "psize" },
{ &e2k_cs.pcur, offsetof(CPUE2KState, pcur), "pcur" },
{ &e2k_cs.boff, offsetof(CPUE2KState, bn.base), "boff" },
{ &e2k_cs.bsize, offsetof(CPUE2KState, bn.size), "bsize" },
{ &e2k_cs.bcur, offsetof(CPUE2KState, bn.cur), "bcur" },
{ &e2k_cs.psize, offsetof(CPUE2KState, bp.size), "psize" },
{ &e2k_cs.pcur, offsetof(CPUE2KState, bp.cur), "pcur" },
{ &e2k_cs.is_bp, offsetof(CPUE2KState, is_bp), "is_bp" },
};