motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-31 14:02:05 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

target/rx: Disassemble rx_index_addr into a string

Browse source 
We were eliding all zero indexes.  It is only ld==0 that does
not have an index in the instruction.  This also allows us to
avoid breaking the final print into multiple pieces.

Reviewed-by: Yoshinori Sato <ysato@users.sourceforge.jp>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20190531134315.4109-19-richard.henderson@linaro.org>
Acked-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
This commit is contained in:
Richard Henderson 2019-05-23 08:13:01 -07:00 • committed by Philippe Mathieu-Daudé
parent 4aea3d0c51
commit fa6289e267
1 changed files with 55 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

154
target/rx/disas.c
View file

@ -107,49 +107,42 @@ static const char psw[] = {
'i', 'u', 0, 0, 0, 0, 0, 0, 'i', 'u', 0, 0, 0, 0, 0, 0,
}; };
static uint32_t rx_index_addr(int ld, int size, DisasContext *ctx) static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)
{ {
bfd_byte buf[2]; uint32_t addr = ctx->addr;
uint8_t buf[2];
uint16_t dsp;
switch (ld) { switch (ld) {
case 0: case 0:
return 0; /* No index; return empty string. */
out[0] = '\0';
return;
case 1: case 1:
ctx->dis->read_memory_func(ctx->addr, buf, 1, ctx->dis);
ctx->addr += 1; ctx->addr += 1;
return ((uint8_t)buf[0]) << size; ctx->dis->read_memory_func(addr, buf, 1, ctx->dis);
dsp = buf[0];
break;
case 2: case 2:
ctx->dis->read_memory_func(ctx->addr, buf, 2, ctx->dis);
ctx->addr += 2; ctx->addr += 2;
return lduw_le_p(buf) << size; ctx->dis->read_memory_func(addr, buf, 2, ctx->dis);
} dsp = lduw_le_p(buf);
break;
default:
g_assert_not_reached(); g_assert_not_reached();
}
sprintf(out, "%u", dsp << (mi < 3 ? mi : 4 - mi));
} }
static void operand(DisasContext *ctx, int ld, int mi, int rs, int rd) static void operand(DisasContext *ctx, int ld, int mi, int rs, int rd)
{ {
int dsp;
static const char sizes[][4] = {".b", ".w", ".l", ".uw", ".ub"}; static const char sizes[][4] = {".b", ".w", ".l", ".uw", ".ub"};
char dsp[8];
if (ld < 3) { if (ld < 3) {
switch (mi) { rx_index_addr(ctx, dsp, ld, mi);
case 4: prt("%s[r%d]%s", dsp, rs, sizes[mi]);
/* dsp[rs].ub */
dsp = rx_index_addr(ld, RX_MEMORY_BYTE, ctx);
break;
case 3:
/* dsp[rs].uw */
dsp = rx_index_addr(ld, RX_MEMORY_WORD, ctx);
break;
default:
/* dsp[rs].b */
/* dsp[rs].w */
/* dsp[rs].l */
dsp = rx_index_addr(ld, mi, ctx);
break;
}
if (dsp > 0) {
prt("%d", dsp);
}
prt("[r%d]%s", rs, sizes[mi]);
} else { } else {
prt("r%d", rs); prt("r%d", rs);
} }
@ -235,7 +228,7 @@ static bool trans_MOV_ra(DisasContext *ctx, arg_MOV_ra *a)
/* mov.[bwl] rs,rd */ /* mov.[bwl] rs,rd */
static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a) static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a)
{ {
int dsp; char dspd[8], dsps[8];
prt("mov.%c\t", size[a->sz]); prt("mov.%c\t", size[a->sz]);
if (a->lds == 3 && a->ldd == 3) { if (a->lds == 3 && a->ldd == 3) {
@ -244,29 +237,15 @@ static bool trans_MOV_mm(DisasContext *ctx, arg_MOV_mm *a)
return true; return true;
} }
if (a->lds == 3) { if (a->lds == 3) {
prt("r%d, ", a->rd); rx_index_addr(ctx, dspd, a->ldd, a->sz);
dsp = rx_index_addr(a->ldd, a->sz, ctx); prt("r%d, %s[r%d]", a->rs, dspd, a->rd);
if (dsp > 0) {
prt("%d", dsp);
}
prt("[r%d]", a->rs);
} else if (a->ldd == 3) { } else if (a->ldd == 3) {
dsp = rx_index_addr(a->lds, a->sz, ctx); rx_index_addr(ctx, dsps, a->lds, a->sz);
if (dsp > 0) { prt("%s[r%d], r%d", dsps, a->rs, a->rd);
prt("%d", dsp);
}
prt("[r%d], r%d", a->rs, a->rd);
} else { } else {
dsp = rx_index_addr(a->lds, a->sz, ctx); rx_index_addr(ctx, dsps, a->lds, a->sz);
if (dsp > 0) { rx_index_addr(ctx, dspd, a->ldd, a->sz);
prt("%d", dsp); prt("%s[r%d], %s[r%d]", dsps, a->rs, dspd, a->rd);
}
prt("[r%d], ", a->rs);
dsp = rx_index_addr(a->ldd, a->sz, ctx);
if (dsp > 0) {
prt("%d", dsp);
}
prt("[r%d]", a->rd);
} }
return true; return true;
} }
@ -357,12 +336,10 @@ static bool trans_PUSH_r(DisasContext *ctx, arg_PUSH_r *a)
/* push dsp[rs] */ /* push dsp[rs] */
static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a) static bool trans_PUSH_m(DisasContext *ctx, arg_PUSH_m *a)
{ {
prt("push\t"); char dsp[8];
int dsp = rx_index_addr(a->ld, a->sz, ctx);
if (dsp > 0) { rx_index_addr(ctx, dsp, a->ld, a->sz);
prt("%d", dsp); prt("push\t%s[r%d]", dsp, a->rs);
}
prt("[r%d]", a->rs);
return true; return true;
} }
@ -389,17 +366,13 @@ static bool trans_XCHG_rr(DisasContext *ctx, arg_XCHG_rr *a)
/* xchg dsp[rs].<mi>,rd */ /* xchg dsp[rs].<mi>,rd */
static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a) static bool trans_XCHG_mr(DisasContext *ctx, arg_XCHG_mr *a)
{ {
int dsp;
static const char msize[][4] = { static const char msize[][4] = {
"b", "w", "l", "ub", "uw", "b", "w", "l", "ub", "uw",
}; };
char dsp[8];
prt("xchg\t"); rx_index_addr(ctx, dsp, a->ld, a->mi);
dsp = rx_index_addr(a->ld, a->mi, ctx); prt("xchg\t%s[r%d].%s, r%d", dsp, a->rs, msize[a->mi], a->rd);
if (dsp > 0) {
prt("%d", dsp);
}
prt("[r%d].%s, r%d", a->rs, msize[a->mi], a->rd);
return true; return true;
} }
@ -552,13 +525,10 @@ static bool trans_ADC_rr(DisasContext *ctx, arg_ADC_rr *a)
/* adc dsp[rs], rd */ /* adc dsp[rs], rd */
static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a) static bool trans_ADC_mr(DisasContext *ctx, arg_ADC_mr *a)
{ {
int dsp; char dsp[8];
prt("adc\t");
dsp = rx_index_addr(a->ld, 2, ctx); rx_index_addr(ctx, dsp, a->ld, 2);
if (dsp > 0) { prt("adc\t%s[r%d], r%d", dsp, a->rs, a->rd);
prt("%d", dsp);
}
prt("[r%d], r%d", a->rs, a->rd);
return true; return true;
} }
@ -1217,25 +1187,17 @@ static bool trans_ITOF(DisasContext *ctx, arg_ITOF *a)
#define BOP_IM(name, reg) \ #define BOP_IM(name, reg) \
do { \ do { \
int dsp; \ char dsp[8]; \
prt("b%s\t#%d, ", #name, a->imm); \ rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \
dsp = rx_index_addr(a->ld, RX_MEMORY_BYTE, ctx); \ prt("b%s\t#%d, %s[r%d]", #name, a->imm, dsp, reg); \
if (dsp > 0) { \
prt("%d", dsp); \
} \
prt("[r%d]", reg); \
return true; \ return true; \
} while (0) } while (0)
#define BOP_RM(name) \ #define BOP_RM(name) \
do { \ do { \
int dsp; \ char dsp[8]; \
prt("b%s\tr%d, ", #name, a->rd); \ rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE); \
dsp = rx_index_addr(a->ld, RX_MEMORY_BYTE, ctx); \ prt("b%s\tr%d, %s[r%d]", #name, a->rd, dsp, a->rs); \
if (dsp > 0) { \
prt("%d", dsp); \
} \
prt("[r%d]", a->rs); \
return true; \ return true; \
} while (0) } while (0)
@ -1346,12 +1308,10 @@ static bool trans_BNOT_ir(DisasContext *ctx, arg_BNOT_ir *a)
/* bmcond #imm, dsp[rd] */ /* bmcond #imm, dsp[rd] */
static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a) static bool trans_BMCnd_im(DisasContext *ctx, arg_BMCnd_im *a)
{ {
int dsp = rx_index_addr(a->ld, RX_MEMORY_BYTE, ctx); char dsp[8];
prt("bm%s\t#%d, ", cond[a->cd], a->imm);
if (dsp > 0) { rx_index_addr(ctx, dsp, a->ld, RX_MEMORY_BYTE);
prt("%d", dsp); prt("bm%s\t#%d, %s[r%d]", cond[a->cd], a->imm, dsp, a->rd);
}
prt("[%d]", a->rd);
return true; return true;
} }
@ -1443,16 +1403,12 @@ static bool trans_WAIT(DisasContext *ctx, arg_WAIT *a)
/* sccnd.[bwl] dsp:[rd] */ /* sccnd.[bwl] dsp:[rd] */
static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a) static bool trans_SCCnd(DisasContext *ctx, arg_SCCnd *a)
{ {
int dsp;
prt("sc%s.%c\t", cond[a->cd], size[a->sz]);
if (a->ld < 3) { if (a->ld < 3) {
dsp = rx_index_addr(a->sz, a->ld, ctx); char dsp[8];
if (dsp > 0) { rx_index_addr(ctx, dsp, a->sz, a->ld);
prt("%d", dsp); prt("sc%s.%c\t%s[r%d]", cond[a->cd], size[a->sz], dsp, a->rd);
}
prt("[r%d]", a->rd);
} else { } else {
prt("r%d", a->rd); prt("sc%s.%c\tr%d", cond[a->cd], size[a->sz], a->rd);
} }
return true; return true;
} }