mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tcg: Widen gen_insn_data to uint64_t

Browse Source 
We already pass uint64_t to restore_state_to_opc; this changes all
of the other uses from insn_start through the encoding to decoding.

Reviewed-by: Anton Johansson <anjo@rev.ng>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2023-03-08 12:24:41 -08:00
parent a1429ca26e
commit c9ad8d27ca
5 changed files with 45 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
accel/tcg/translate-all.c
View File

@ -72,9 +72,11 @@ QEMU_BUILD_BUG_ON(CPU_TRACE_DSTATE_MAX_EVENTS >
TBContext tb_ctx; TBContext tb_ctx;
/* Encode VAL as a signed leb128 sequence at P. /*
Return P incremented past the encoded value. */ * Encode VAL as a signed leb128 sequence at P.
static uint8_t *encode_sleb128(uint8_t *p, target_long val) * Return P incremented past the encoded value.
*/
static uint8_t *encode_sleb128(uint8_t *p, int64_t val)
{ {
int more, byte; int more, byte;
@ -92,21 +94,23 @@ static uint8_t *encode_sleb128(uint8_t *p, target_long val)
return p; return p;
} }
/* Decode a signed leb128 sequence at *PP; increment *PP past the /*
decoded value. Return the decoded value. */ * Decode a signed leb128 sequence at *PP; increment *PP past the
static target_long decode_sleb128(const uint8_t **pp) * decoded value. Return the decoded value.
*/
static int64_t decode_sleb128(const uint8_t **pp)
{ {
const uint8_t *p = *pp; const uint8_t *p = *pp;
target_long val = 0; int64_t val = 0;
int byte, shift = 0; int byte, shift = 0;
do { do {
byte = *p++; byte = *p++;
val |= (target_ulong)(byte & 0x7f) << shift; val |= (int64_t)(byte & 0x7f) << shift;
shift += 7; shift += 7;
} while (byte & 0x80); } while (byte & 0x80);
if (shift < TARGET_LONG_BITS && (byte & 0x40)) { if (shift < TARGET_LONG_BITS && (byte & 0x40)) {
val |= -(target_ulong)1 << shift; val |= -(int64_t)1 << shift;
} }
*pp = p; *pp = p;
@ -132,7 +136,7 @@ static int encode_search(TranslationBlock *tb, uint8_t *block)
int i, j, n; int i, j, n;
for (i = 0, n = tb->icount; i < n; ++i) { for (i = 0, n = tb->icount; i < n; ++i) {
target_ulong prev; uint64_t prev;
for (j = 0; j < TARGET_INSN_START_WORDS; ++j) { for (j = 0; j < TARGET_INSN_START_WORDS; ++j) {
if (i == 0) { if (i == 0) {
@ -444,7 +448,7 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
/* Dump header and the first instruction */ /* Dump header and the first instruction */
fprintf(logfile, "OUT: [size=%d]\n", gen_code_size); fprintf(logfile, "OUT: [size=%d]\n", gen_code_size);
fprintf(logfile, fprintf(logfile,
" -- guest addr 0x" TARGET_FMT_lx " + tb prologue\n", " -- guest addr 0x%016" PRIx64 " + tb prologue\n",
tcg_ctx->gen_insn_data[insn][0]); tcg_ctx->gen_insn_data[insn][0]);
chunk_start = tcg_ctx->gen_insn_end_off[insn]; chunk_start = tcg_ctx->gen_insn_end_off[insn];
disas(logfile, tb->tc.ptr, chunk_start); disas(logfile, tb->tc.ptr, chunk_start);
@ -457,7 +461,7 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
while (insn < tb->icount) { while (insn < tb->icount) {
size_t chunk_end = tcg_ctx->gen_insn_end_off[insn]; size_t chunk_end = tcg_ctx->gen_insn_end_off[insn];
if (chunk_end > chunk_start) { if (chunk_end > chunk_start) {
fprintf(logfile, " -- guest addr 0x" TARGET_FMT_lx "\n", fprintf(logfile, " -- guest addr 0x%016" PRIx64 "\n",
tcg_ctx->gen_insn_data[insn][0]); tcg_ctx->gen_insn_data[insn][0]);
disas(logfile, tb->tc.ptr + chunk_start, disas(logfile, tb->tc.ptr + chunk_start,
chunk_end - chunk_start); chunk_end - chunk_start);

39
include/tcg/tcg-op.h
View File

@ -723,48 +723,27 @@ static inline void tcg_gen_concat32_i64(TCGv_i64 ret, TCGv_i64 lo, TCGv_i64 hi)
#endif #endif
#if TARGET_INSN_START_WORDS == 1 #if TARGET_INSN_START_WORDS == 1
# if TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
static inline void tcg_gen_insn_start(target_ulong pc) static inline void tcg_gen_insn_start(target_ulong pc)
{ {
tcg_gen_op1(INDEX_op_insn_start, pc); TCGOp *op = tcg_emit_op(INDEX_op_insn_start, 64 / TCG_TARGET_REG_BITS);
tcg_set_insn_start_param(op, 0, pc);
} }
# else
static inline void tcg_gen_insn_start(target_ulong pc)
{
tcg_gen_op2(INDEX_op_insn_start, (uint32_t)pc, (uint32_t)(pc >> 32));
}
# endif
#elif TARGET_INSN_START_WORDS == 2 #elif TARGET_INSN_START_WORDS == 2
# if TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1) static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1)
{ {
tcg_gen_op2(INDEX_op_insn_start, pc, a1); TCGOp *op = tcg_emit_op(INDEX_op_insn_start, 2 * 64 / TCG_TARGET_REG_BITS);
tcg_set_insn_start_param(op, 0, pc);
tcg_set_insn_start_param(op, 1, a1);
} }
# else
static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1)
{
tcg_gen_op4(INDEX_op_insn_start,
(uint32_t)pc, (uint32_t)(pc >> 32),
(uint32_t)a1, (uint32_t)(a1 >> 32));
}
# endif
#elif TARGET_INSN_START_WORDS == 3 #elif TARGET_INSN_START_WORDS == 3
# if TARGET_LONG_BITS <= TCG_TARGET_REG_BITS
static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1, static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1,
target_ulong a2) target_ulong a2)
{ {
tcg_gen_op3(INDEX_op_insn_start, pc, a1, a2); TCGOp *op = tcg_emit_op(INDEX_op_insn_start, 3 * 64 / TCG_TARGET_REG_BITS);
tcg_set_insn_start_param(op, 0, pc);
tcg_set_insn_start_param(op, 1, a1);
tcg_set_insn_start_param(op, 2, a2);
} }
# else
static inline void tcg_gen_insn_start(target_ulong pc, target_ulong a1,
target_ulong a2)
{
tcg_gen_op6(INDEX_op_insn_start,
(uint32_t)pc, (uint32_t)(pc >> 32),
(uint32_t)a1, (uint32_t)(a1 >> 32),
(uint32_t)a2, (uint32_t)(a2 >> 32));
}
# endif
#else #else
# error "Unhandled number of operands to insn_start" # error "Unhandled number of operands to insn_start"
#endif #endif

2
include/tcg/tcg-opc.h
View File

@ -190,7 +190,7 @@ DEF(mulsh_i64, 1, 2, 0, IMPL64 | IMPL(TCG_TARGET_HAS_mulsh_i64))
#define DATA64_ARGS (TCG_TARGET_REG_BITS == 64 ? 1 : 2) #define DATA64_ARGS (TCG_TARGET_REG_BITS == 64 ? 1 : 2)
/* QEMU specific */ /* QEMU specific */
DEF(insn_start, 0, 0, TLADDR_ARGS * TARGET_INSN_START_WORDS, DEF(insn_start, 0, 0, DATA64_ARGS * TARGET_INSN_START_WORDS,
TCG_OPF_NOT_PRESENT) TCG_OPF_NOT_PRESENT)
DEF(exit_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END) DEF(exit_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
DEF(goto_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END) DEF(goto_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)

22
include/tcg/tcg.h
View File

@ -629,7 +629,7 @@ struct TCGContext {
TCGTemp *reg_to_temp[TCG_TARGET_NB_REGS]; TCGTemp *reg_to_temp[TCG_TARGET_NB_REGS];
uint16_t gen_insn_end_off[TCG_MAX_INSNS]; uint16_t gen_insn_end_off[TCG_MAX_INSNS];
target_ulong gen_insn_data[TCG_MAX_INSNS][TARGET_INSN_START_WORDS]; uint64_t gen_insn_data[TCG_MAX_INSNS][TARGET_INSN_START_WORDS];
/* Exit to translator on overflow. */ /* Exit to translator on overflow. */
sigjmp_buf jmp_trans; sigjmp_buf jmp_trans;
@ -771,24 +771,24 @@ static inline void tcg_set_insn_param(TCGOp *op, int arg, TCGArg v)
op->args[arg] = v; op->args[arg] = v;
} }
static inline target_ulong tcg_get_insn_start_param(TCGOp *op, int arg) static inline uint64_t tcg_get_insn_start_param(TCGOp *op, int arg)
{ {
#if TARGET_LONG_BITS <= TCG_TARGET_REG_BITS if (TCG_TARGET_REG_BITS == 64) {
return tcg_get_insn_param(op, arg); return tcg_get_insn_param(op, arg);
#else } else {
return tcg_get_insn_param(op, arg * 2) | return deposit64(tcg_get_insn_param(op, arg * 2), 32, 32,
((uint64_t)tcg_get_insn_param(op, arg * 2 + 1) << 32); tcg_get_insn_param(op, arg * 2 + 1));
#endif }
} }
static inline void tcg_set_insn_start_param(TCGOp *op, int arg, target_ulong v) static inline void tcg_set_insn_start_param(TCGOp *op, int arg, uint64_t v)
{ {
#if TARGET_LONG_BITS <= TCG_TARGET_REG_BITS if (TCG_TARGET_REG_BITS == 64) {
tcg_set_insn_param(op, arg, v); tcg_set_insn_param(op, arg, v);
#else } else {
tcg_set_insn_param(op, arg * 2, v); tcg_set_insn_param(op, arg * 2, v);
tcg_set_insn_param(op, arg * 2 + 1, v >> 32); tcg_set_insn_param(op, arg * 2 + 1, v >> 32);
#endif }
} }
/* The last op that was emitted. */ /* The last op that was emitted. */

18
tcg/tcg.c
View File

@ -2384,13 +2384,8 @@ static void tcg_dump_ops(TCGContext *s, FILE *f, bool have_prefs)
col += ne_fprintf(f, "\n ----"); col += ne_fprintf(f, "\n ----");
for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { for (i = 0; i < TARGET_INSN_START_WORDS; ++i) {
target_ulong a; col += ne_fprintf(f, " %016" PRIx64,
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS tcg_get_insn_start_param(op, i));
a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]);
#else
a = op->args[i];
#endif
col += ne_fprintf(f, " " TARGET_FMT_lx, a);
} }
} else if (c == INDEX_op_call) { } else if (c == INDEX_op_call) {
const TCGHelperInfo *info = tcg_call_info(op); const TCGHelperInfo *info = tcg_call_info(op);
@ -6081,13 +6076,8 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb, target_ulong pc_start)
} }
num_insns++; num_insns++;
for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { for (i = 0; i < TARGET_INSN_START_WORDS; ++i) {
target_ulong a; s->gen_insn_data[num_insns][i] =
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS tcg_get_insn_start_param(op, i);
a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]);
#else
a = op->args[i];
#endif
s->gen_insn_data[num_insns][i] = a;
} }
break; break;
case INDEX_op_discard: case INDEX_op_discard: