system/qemu
system/qemu
1
0
Fork 0
mirror of https://gitlab.com/qemu-project/qemu synced 2024-09-28 23:34:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

disas/riscv: Use GString in format_inst

Browse source 
Allocate and fill a GString instead of snprintf and
appending to a fixed sized buffer.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
Message-Id: <20240412073346.458116-22-richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2024-04-12 00:33:40 -07:00
parent a45e0b5290
commit b89fb575fd
1 changed files with 92 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
disas/riscv.c
View file

@ -4820,272 +4820,249 @@ static size_t inst_length(rv_inst inst)
/* format instruction */ /* format instruction */
static void append(char *s1, const char *s2, size_t n) static GString *format_inst(size_t tab, rv_decode *dec)
{
size_t l1 = strlen(s1);
if (n - l1 - 1 > 0) {
strncat(s1, s2, n - l1);
}
}
static void format_inst(char *buf, size_t buflen, size_t tab, rv_decode *dec)
{ {
const rv_opcode_data *opcode_data = dec->opcode_data; const rv_opcode_data *opcode_data = dec->opcode_data;
char tmp[64]; GString *buf = g_string_sized_new(64);
const char *fmt; const char *fmt;
fmt = opcode_data[dec->op].format; fmt = opcode_data[dec->op].format;
while (*fmt) { while (*fmt) {
switch (*fmt) { switch (*fmt) {
case 'O': case 'O':
append(buf, opcode_data[dec->op].name, buflen); g_string_append(buf, opcode_data[dec->op].name);
break; break;
case '(': case '(':
append(buf, "(", buflen);
break;
case ',': case ',':
append(buf, ",", buflen);
break;
case ')': case ')':
append(buf, ")", buflen);
break;
case '-': case '-':
append(buf, "-", buflen); g_string_append_c(buf, *fmt);
break; break;
case 'b': case 'b':
snprintf(tmp, sizeof(tmp), "%d", dec->bs); g_string_append_printf(buf, "%d", dec->bs);
append(buf, tmp, buflen);
break; break;
case 'n': case 'n':
snprintf(tmp, sizeof(tmp), "%d", dec->rnum); g_string_append_printf(buf, "%d", dec->rnum);
append(buf, tmp, buflen);
break; break;
case '0': case '0':
append(buf, rv_ireg_name_sym[dec->rd], buflen); g_string_append(buf, rv_ireg_name_sym[dec->rd]);
break; break;
case '1': case '1':
append(buf, rv_ireg_name_sym[dec->rs1], buflen); g_string_append(buf, rv_ireg_name_sym[dec->rs1]);
break; break;
case '2': case '2':
append(buf, rv_ireg_name_sym[dec->rs2], buflen); g_string_append(buf, rv_ireg_name_sym[dec->rs2]);
break; break;
case '3': case '3':
append(buf, dec->cfg->ext_zfinx ? rv_ireg_name_sym[dec->rd] : if (dec->cfg->ext_zfinx) {
rv_freg_name_sym[dec->rd], g_string_append(buf, rv_ireg_name_sym[dec->rd]);
buflen); } else {
g_string_append(buf, rv_freg_name_sym[dec->rd]);
}
break; break;
case '4': case '4':
append(buf, dec->cfg->ext_zfinx ? rv_ireg_name_sym[dec->rs1] : if (dec->cfg->ext_zfinx) {
rv_freg_name_sym[dec->rs1], g_string_append(buf, rv_ireg_name_sym[dec->rs1]);
buflen); } else {
g_string_append(buf, rv_freg_name_sym[dec->rs1]);
}
break; break;
case '5': case '5':
append(buf, dec->cfg->ext_zfinx ? rv_ireg_name_sym[dec->rs2] : if (dec->cfg->ext_zfinx) {
rv_freg_name_sym[dec->rs2], g_string_append(buf, rv_ireg_name_sym[dec->rs2]);
buflen); } else {
g_string_append(buf, rv_freg_name_sym[dec->rs2]);
}
break; break;
case '6': case '6':
append(buf, dec->cfg->ext_zfinx ? rv_ireg_name_sym[dec->rs3] : if (dec->cfg->ext_zfinx) {
rv_freg_name_sym[dec->rs3], g_string_append(buf, rv_ireg_name_sym[dec->rs3]);
buflen); } else {
g_string_append(buf, rv_freg_name_sym[dec->rs3]);
}
break; break;
case '7': case '7':
snprintf(tmp, sizeof(tmp), "%d", dec->rs1); g_string_append_printf(buf, "%d", dec->rs1);
append(buf, tmp, buflen);
break; break;
case 'i': case 'i':
snprintf(tmp, sizeof(tmp), "%d", dec->imm); g_string_append_printf(buf, "%d", dec->imm);
append(buf, tmp, buflen);
break; break;
case 'u': case 'u':
snprintf(tmp, sizeof(tmp), "%u", ((uint32_t)dec->imm & 0b111111)); g_string_append_printf(buf, "%u", ((uint32_t)dec->imm & 0b111111));
append(buf, tmp, buflen);
break; break;
case 'j': case 'j':
snprintf(tmp, sizeof(tmp), "%d", dec->imm1); g_string_append_printf(buf, "%d", dec->imm1);
append(buf, tmp, buflen);
break; break;
case 'o': case 'o':
snprintf(tmp, sizeof(tmp), "%d", dec->imm); g_string_append_printf(buf, "%d", dec->imm);
append(buf, tmp, buflen); while (buf->len < tab * 2) {
while (strlen(buf) < tab * 2) { g_string_append_c(buf, ' ');
append(buf, " ", buflen);
} }
snprintf(tmp, sizeof(tmp), "# 0x%" PRIx64, g_string_append_printf(buf, "# 0x%" PRIx64, dec->pc + dec->imm);
dec->pc + dec->imm);
append(buf, tmp, buflen);
break; break;
case 'U': case 'U':
fmt++; fmt++;
snprintf(tmp, sizeof(tmp), "%d", dec->imm >> 12); g_string_append_printf(buf, "%d", dec->imm >> 12);
append(buf, tmp, buflen);
if (*fmt == 'o') { if (*fmt == 'o') {
while (strlen(buf) < tab * 2) { while (buf->len < tab * 2) {
append(buf, " ", buflen); g_string_append_c(buf, ' ');
} }
snprintf(tmp, sizeof(tmp), "# 0x%" PRIx64, g_string_append_printf(buf, "# 0x%" PRIx64, dec->pc + dec->imm);
dec->pc + dec->imm);
append(buf, tmp, buflen);
} }
break; break;
case 'c': { case 'c': {
const char *name = csr_name(dec->imm & 0xfff); const char *name = csr_name(dec->imm & 0xfff);
if (name) { if (name) {
append(buf, name, buflen); g_string_append(buf, name);
} else { } else {
snprintf(tmp, sizeof(tmp), "0x%03x", dec->imm & 0xfff); g_string_append_printf(buf, "0x%03x", dec->imm & 0xfff);
append(buf, tmp, buflen);
} }
break; break;
} }
case 'r': case 'r':
switch (dec->rm) { switch (dec->rm) {
case rv_rm_rne: case rv_rm_rne:
append(buf, "rne", buflen); g_string_append(buf, "rne");
break; break;
case rv_rm_rtz: case rv_rm_rtz:
append(buf, "rtz", buflen); g_string_append(buf, "rtz");
break; break;
case rv_rm_rdn: case rv_rm_rdn:
append(buf, "rdn", buflen); g_string_append(buf, "rdn");
break; break;
case rv_rm_rup: case rv_rm_rup:
append(buf, "rup", buflen); g_string_append(buf, "rup");
break; break;
case rv_rm_rmm: case rv_rm_rmm:
append(buf, "rmm", buflen); g_string_append(buf, "rmm");
break; break;
case rv_rm_dyn: case rv_rm_dyn:
append(buf, "dyn", buflen); g_string_append(buf, "dyn");
break; break;
default: default:
append(buf, "inv", buflen); g_string_append(buf, "inv");
break; break;
} }
break; break;
case 'p': case 'p':
if (dec->pred & rv_fence_i) { if (dec->pred & rv_fence_i) {
append(buf, "i", buflen); g_string_append_c(buf, 'i');
} }
if (dec->pred & rv_fence_o) { if (dec->pred & rv_fence_o) {
append(buf, "o", buflen); g_string_append_c(buf, 'o');
} }
if (dec->pred & rv_fence_r) { if (dec->pred & rv_fence_r) {
append(buf, "r", buflen); g_string_append_c(buf, 'r');
} }
if (dec->pred & rv_fence_w) { if (dec->pred & rv_fence_w) {
append(buf, "w", buflen); g_string_append_c(buf, 'w');
} }
break; break;
case 's': case 's':
if (dec->succ & rv_fence_i) { if (dec->succ & rv_fence_i) {
append(buf, "i", buflen); g_string_append_c(buf, 'i');
} }
if (dec->succ & rv_fence_o) { if (dec->succ & rv_fence_o) {
append(buf, "o", buflen); g_string_append_c(buf, 'o');
} }
if (dec->succ & rv_fence_r) { if (dec->succ & rv_fence_r) {
append(buf, "r", buflen); g_string_append_c(buf, 'r');
} }
if (dec->succ & rv_fence_w) { if (dec->succ & rv_fence_w) {
append(buf, "w", buflen); g_string_append_c(buf, 'w');
} }
break; break;
case '\t': case '\t':
while (strlen(buf) < tab) { while (buf->len < tab) {
append(buf, " ", buflen); g_string_append_c(buf, ' ');
} }
break; break;
case 'A': case 'A':
if (dec->aq) { if (dec->aq) {
append(buf, ".aq", buflen); g_string_append(buf, ".aq");
} }
break; break;
case 'R': case 'R':
if (dec->rl) { if (dec->rl) {
append(buf, ".rl", buflen); g_string_append(buf, ".rl");
} }
break; break;
case 'l': case 'l':
append(buf, ",v0", buflen); g_string_append(buf, ",v0");
break; break;
case 'm': case 'm':
if (dec->vm == 0) { if (dec->vm == 0) {
append(buf, ",v0.t", buflen); g_string_append(buf, ",v0.t");
} }
break; break;
case 'D': case 'D':
append(buf, rv_vreg_name_sym[dec->rd], buflen); g_string_append(buf, rv_vreg_name_sym[dec->rd]);
break; break;
case 'E': case 'E':
append(buf, rv_vreg_name_sym[dec->rs1], buflen); g_string_append(buf, rv_vreg_name_sym[dec->rs1]);
break; break;
case 'F': case 'F':
append(buf, rv_vreg_name_sym[dec->rs2], buflen); g_string_append(buf, rv_vreg_name_sym[dec->rs2]);
break; break;
case 'G': case 'G':
append(buf, rv_vreg_name_sym[dec->rs3], buflen); g_string_append(buf, rv_vreg_name_sym[dec->rs3]);
break; break;
case 'v': { case 'v': {
char nbuf[32] = {0};
const int sew = 1 << (((dec->vzimm >> 3) & 0b111) + 3); const int sew = 1 << (((dec->vzimm >> 3) & 0b111) + 3);
sprintf(nbuf, "%d", sew);
const int lmul = dec->vzimm & 0b11; const int lmul = dec->vzimm & 0b11;
const int flmul = (dec->vzimm >> 2) & 1; const int flmul = (dec->vzimm >> 2) & 1;
const char *vta = (dec->vzimm >> 6) & 1 ? "ta" : "tu"; const char *vta = (dec->vzimm >> 6) & 1 ? "ta" : "tu";
const char *vma = (dec->vzimm >> 7) & 1 ? "ma" : "mu"; const char *vma = (dec->vzimm >> 7) & 1 ? "ma" : "mu";
append(buf, "e", buflen);
append(buf, nbuf, buflen); g_string_append_printf(buf, "e%d,m", sew);
append(buf, ",m", buflen);
if (flmul) { if (flmul) {
switch (lmul) { switch (lmul) {
case 3: case 3:
sprintf(nbuf, "f2"); g_string_append(buf, "f2");
break; break;
case 2: case 2:
sprintf(nbuf, "f4"); g_string_append(buf, "f4");
break; break;
case 1: case 1:
sprintf(nbuf, "f8"); g_string_append(buf, "f8");
break; break;
} }
append(buf, nbuf, buflen);
} else { } else {
sprintf(nbuf, "%d", 1 << lmul); g_string_append_printf(buf, "%d", 1 << lmul);
append(buf, nbuf, buflen);
} }
append(buf, ",", buflen); g_string_append_c(buf, ',');
append(buf, vta, buflen); g_string_append(buf, vta);
append(buf, ",", buflen); g_string_append_c(buf, ',');
append(buf, vma, buflen); g_string_append(buf, vma);
break; break;
} }
case 'x': { case 'x': {
switch (dec->rlist) { switch (dec->rlist) {
case 4: case 4:
snprintf(tmp, sizeof(tmp), "{ra}"); g_string_append(buf, "{ra}");
break; break;
case 5: case 5:
snprintf(tmp, sizeof(tmp), "{ra, s0}"); g_string_append(buf, "{ra, s0}");
break; break;
case 15: case 15:
snprintf(tmp, sizeof(tmp), "{ra, s0-s11}"); g_string_append(buf, "{ra, s0-s11}");
break; break;
default: default:
snprintf(tmp, sizeof(tmp), "{ra, s0-s%d}", dec->rlist - 5); g_string_append_printf(buf, "{ra, s0-s%d}", dec->rlist - 5);
break; break;
} }
append(buf, tmp, buflen);
break; break;
} }
case 'h': case 'h':
append(buf, rv_fli_name_const[dec->imm], buflen); g_string_append(buf, rv_fli_name_const[dec->imm]);
break; break;
default: default:
break; break;
} }
fmt++; fmt++;
} }
return buf;
} }
/* lift instruction to pseudo-instruction */ /* lift instruction to pseudo-instruction */
@ -5171,9 +5148,8 @@ static void decode_inst_decompress(rv_decode *dec, rv_isa isa)
/* disassemble instruction */ /* disassemble instruction */
static void static GString *disasm_inst(rv_isa isa, uint64_t pc, rv_inst inst,
disasm_inst(char *buf, size_t buflen, rv_isa isa, uint64_t pc, rv_inst inst, RISCVCPUConfig *cfg)
RISCVCPUConfig *cfg)
{ {
rv_decode dec = { 0 }; rv_decode dec = { 0 };
dec.pc = pc; dec.pc = pc;
@ -5220,7 +5196,7 @@ disasm_inst(char *buf, size_t buflen, rv_isa isa, uint64_t pc, rv_inst inst,
decode_inst_operands(&dec, isa); decode_inst_operands(&dec, isa);
decode_inst_decompress(&dec, isa); decode_inst_decompress(&dec, isa);
decode_inst_lift_pseudo(&dec); decode_inst_lift_pseudo(&dec);
format_inst(buf, buflen, 24, &dec); return format_inst(24, &dec);
} }
#define INST_FMT_2 "%04" PRIx64 " " #define INST_FMT_2 "%04" PRIx64 " "
@ -5231,7 +5207,6 @@ disasm_inst(char *buf, size_t buflen, rv_isa isa, uint64_t pc, rv_inst inst,
static int static int
print_insn_riscv(bfd_vma memaddr, struct disassemble_info *info, rv_isa isa) print_insn_riscv(bfd_vma memaddr, struct disassemble_info *info, rv_isa isa)
{ {
char buf[128] = { 0 };
bfd_byte packet[2]; bfd_byte packet[2];
rv_inst inst = 0; rv_inst inst = 0;
size_t len = 2; size_t len = 2;
@ -5272,9 +5247,9 @@ print_insn_riscv(bfd_vma memaddr, struct disassemble_info *info, rv_isa isa)
} }
} }
disasm_inst(buf, sizeof(buf), isa, memaddr, inst, g_autoptr(GString) str =
(RISCVCPUConfig *)info->target_info); disasm_inst(isa, memaddr, inst, (RISCVCPUConfig *)info->target_info);
(*info->fprintf_func)(info->stream, "%s", buf); (*info->fprintf_func)(info->stream, "%s", str->str);
return len; return len;
} }