From: Pierrick Bouvier <pierrick.bouvier@linaro.org>
To: Richard Henderson <richard.henderson@linaro.org>, qemu-devel@nongnu.org
Cc: alex.bennee@linaro.org
Subject: Re: [PATCH 11/22] plugins: Use emit_before_op for PLUGIN_GEN_FROM_MEM
Date: Tue, 19 Mar 2024 17:35:14 +0400 [thread overview]
Message-ID: <21bbcdb3-16a2-4cd5-adb1-a42733866d63@linaro.org> (raw)
In-Reply-To: <20240316015720.3661236-12-richard.henderson@linaro.org>
On 3/16/24 05:57, Richard Henderson wrote:
> Introduce a new plugin_mem_cb op to hold the address temp
> and meminfo computed by tcg-op-ldst.c. Because this now
> has its own opcode, we no longer need PLUGIN_GEN_FROM_MEM.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> include/exec/plugin-gen.h | 4 -
> include/tcg/tcg-op-common.h | 1 +
> include/tcg/tcg-opc.h | 1 +
> accel/tcg/plugin-gen.c | 408 ++++--------------------------------
> tcg/tcg-op-ldst.c | 6 +-
> tcg/tcg-op.c | 5 +
> 6 files changed, 54 insertions(+), 371 deletions(-)
>
> diff --git a/include/exec/plugin-gen.h b/include/exec/plugin-gen.h
> index c4552b5061..f333f33198 100644
> --- a/include/exec/plugin-gen.h
> +++ b/include/exec/plugin-gen.h
> @@ -25,7 +25,6 @@ void plugin_gen_insn_start(CPUState *cpu, const struct DisasContextBase *db);
> void plugin_gen_insn_end(void);
>
> void plugin_gen_disable_mem_helpers(void);
> -void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info);
>
> #else /* !CONFIG_PLUGIN */
>
> @@ -48,9 +47,6 @@ static inline void plugin_gen_tb_end(CPUState *cpu, size_t num_insns)
> static inline void plugin_gen_disable_mem_helpers(void)
> { }
>
> -static inline void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info)
> -{ }
> -
> #endif /* CONFIG_PLUGIN */
>
> #endif /* QEMU_PLUGIN_GEN_H */
> diff --git a/include/tcg/tcg-op-common.h b/include/tcg/tcg-op-common.h
> index 9de5a7f280..72b80b20d0 100644
> --- a/include/tcg/tcg-op-common.h
> +++ b/include/tcg/tcg-op-common.h
> @@ -75,6 +75,7 @@ void tcg_gen_goto_tb(unsigned idx);
> void tcg_gen_lookup_and_goto_ptr(void);
>
> void tcg_gen_plugin_cb(unsigned from);
> +void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo);
> void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr);
> void tcg_gen_plugin_cb_end(void);
>
> diff --git a/include/tcg/tcg-opc.h b/include/tcg/tcg-opc.h
> index 3b7cb2bce1..be9e36e386 100644
> --- a/include/tcg/tcg-opc.h
> +++ b/include/tcg/tcg-opc.h
> @@ -198,6 +198,7 @@ DEF(goto_tb, 0, 0, 1, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
> DEF(goto_ptr, 0, 1, 0, TCG_OPF_BB_EXIT | TCG_OPF_BB_END)
>
> DEF(plugin_cb, 0, 0, 1, TCG_OPF_NOT_PRESENT)
> +DEF(plugin_mem_cb, 0, 1, 1, TCG_OPF_NOT_PRESENT)
> DEF(plugin_cb_start, 0, 0, 3, TCG_OPF_NOT_PRESENT)
> DEF(plugin_cb_end, 0, 0, 0, TCG_OPF_NOT_PRESENT)
>
> diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
> index 4785838eca..be7fd548cc 100644
> --- a/accel/tcg/plugin-gen.c
> +++ b/accel/tcg/plugin-gen.c
> @@ -73,7 +73,6 @@
> enum plugin_gen_from {
> PLUGIN_GEN_FROM_TB,
> PLUGIN_GEN_FROM_INSN,
> - PLUGIN_GEN_FROM_MEM,
> PLUGIN_GEN_AFTER_INSN,
> PLUGIN_GEN_AFTER_TB,
> PLUGIN_GEN_N_FROMS,
> @@ -104,60 +103,6 @@ void HELPER(plugin_vcpu_mem_cb)(unsigned int vcpu_index,
> void *userdata)
> { }
>
> -/*
> - * For now we only support addi_i64.
> - * When we support more ops, we can generate one empty inline cb for each.
> - */
> -static void gen_empty_inline_cb(void)
> -{
> - TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
> - TCGv_ptr cpu_index_as_ptr = tcg_temp_ebb_new_ptr();
> - TCGv_i64 val = tcg_temp_ebb_new_i64();
> - TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
> -
> - tcg_gen_ld_i32(cpu_index, tcg_env,
> - -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
> - /* second operand will be replaced by immediate value */
> - tcg_gen_mul_i32(cpu_index, cpu_index, cpu_index);
> - tcg_gen_ext_i32_ptr(cpu_index_as_ptr, cpu_index);
> -
> - tcg_gen_movi_ptr(ptr, 0);
> - tcg_gen_add_ptr(ptr, ptr, cpu_index_as_ptr);
> - tcg_gen_ld_i64(val, ptr, 0);
> - /* second operand will be replaced by immediate value */
> - tcg_gen_add_i64(val, val, val);
> -
> - tcg_gen_st_i64(val, ptr, 0);
> - tcg_temp_free_ptr(ptr);
> - tcg_temp_free_i64(val);
> - tcg_temp_free_ptr(cpu_index_as_ptr);
> - tcg_temp_free_i32(cpu_index);
> -}
> -
> -static void gen_empty_mem_cb(TCGv_i64 addr, uint32_t info)
> -{
> - TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
> - TCGv_i32 meminfo = tcg_temp_ebb_new_i32();
> - TCGv_ptr udata = tcg_temp_ebb_new_ptr();
> -
> - tcg_gen_movi_i32(meminfo, info);
> - tcg_gen_movi_ptr(udata, 0);
> - tcg_gen_ld_i32(cpu_index, tcg_env,
> - -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
> -
> - gen_helper_plugin_vcpu_mem_cb(cpu_index, meminfo, addr, udata);
> -
> - tcg_temp_free_ptr(udata);
> - tcg_temp_free_i32(meminfo);
> - tcg_temp_free_i32(cpu_index);
> -}
> -
> -static void gen_plugin_cb_start(enum plugin_gen_from from,
> - enum plugin_gen_cb type, unsigned wr)
> -{
> - tcg_gen_plugin_cb_start(from, type, wr);
> -}
> -
> static void plugin_gen_empty_callback(enum plugin_gen_from from)
> {
> switch (from) {
> @@ -171,278 +116,6 @@ static void plugin_gen_empty_callback(enum plugin_gen_from from)
> }
> }
>
> -void plugin_gen_empty_mem_callback(TCGv_i64 addr, uint32_t info)
> -{
> - enum qemu_plugin_mem_rw rw = get_plugin_meminfo_rw(info);
> -
> - gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, PLUGIN_GEN_CB_MEM, rw);
> - gen_empty_mem_cb(addr, info);
> - tcg_gen_plugin_cb_end();
> -
> - gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, PLUGIN_GEN_CB_INLINE, rw);
> - gen_empty_inline_cb();
> - tcg_gen_plugin_cb_end();
> -}
> -
> -static TCGOp *find_op(TCGOp *op, TCGOpcode opc)
> -{
> - while (op) {
> - if (op->opc == opc) {
> - return op;
> - }
> - op = QTAILQ_NEXT(op, link);
> - }
> - return NULL;
> -}
> -
> -static TCGOp *rm_ops_range(TCGOp *begin, TCGOp *end)
> -{
> - TCGOp *ret = QTAILQ_NEXT(end, link);
> -
> - QTAILQ_REMOVE_SEVERAL(&tcg_ctx->ops, begin, end, link);
> - return ret;
> -}
> -
> -/* remove all ops until (and including) plugin_cb_end */
> -static TCGOp *rm_ops(TCGOp *op)
> -{
> - TCGOp *end_op = find_op(op, INDEX_op_plugin_cb_end);
> -
> - tcg_debug_assert(end_op);
> - return rm_ops_range(op, end_op);
> -}
> -
> -static TCGOp *copy_op_nocheck(TCGOp **begin_op, TCGOp *op)
> -{
> - TCGOp *old_op = QTAILQ_NEXT(*begin_op, link);
> - unsigned nargs = old_op->nargs;
> -
> - *begin_op = old_op;
> - op = tcg_op_insert_after(tcg_ctx, op, old_op->opc, nargs);
> - memcpy(op->args, old_op->args, sizeof(op->args[0]) * nargs);
> -
> - return op;
> -}
> -
> -static TCGOp *copy_op(TCGOp **begin_op, TCGOp *op, TCGOpcode opc)
> -{
> - op = copy_op_nocheck(begin_op, op);
> - tcg_debug_assert((*begin_op)->opc == opc);
> - return op;
> -}
> -
> -static TCGOp *copy_const_ptr(TCGOp **begin_op, TCGOp *op, void *ptr)
> -{
> - if (UINTPTR_MAX == UINT32_MAX) {
> - /* mov_i32 */
> - op = copy_op(begin_op, op, INDEX_op_mov_i32);
> - op->args[1] = tcgv_i32_arg(tcg_constant_i32((uintptr_t)ptr));
> - } else {
> - /* mov_i64 */
> - op = copy_op(begin_op, op, INDEX_op_mov_i64);
> - op->args[1] = tcgv_i64_arg(tcg_constant_i64((uintptr_t)ptr));
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_ld_i32(TCGOp **begin_op, TCGOp *op)
> -{
> - return copy_op(begin_op, op, INDEX_op_ld_i32);
> -}
> -
> -static TCGOp *copy_ext_i32_ptr(TCGOp **begin_op, TCGOp *op)
> -{
> - if (UINTPTR_MAX == UINT32_MAX) {
> - op = copy_op(begin_op, op, INDEX_op_mov_i32);
> - } else {
> - op = copy_op(begin_op, op, INDEX_op_ext_i32_i64);
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_add_ptr(TCGOp **begin_op, TCGOp *op)
> -{
> - if (UINTPTR_MAX == UINT32_MAX) {
> - op = copy_op(begin_op, op, INDEX_op_add_i32);
> - } else {
> - op = copy_op(begin_op, op, INDEX_op_add_i64);
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_ld_i64(TCGOp **begin_op, TCGOp *op)
> -{
> - if (TCG_TARGET_REG_BITS == 32) {
> - /* 2x ld_i32 */
> - op = copy_ld_i32(begin_op, op);
> - op = copy_ld_i32(begin_op, op);
> - } else {
> - /* ld_i64 */
> - op = copy_op(begin_op, op, INDEX_op_ld_i64);
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_st_i64(TCGOp **begin_op, TCGOp *op)
> -{
> - if (TCG_TARGET_REG_BITS == 32) {
> - /* 2x st_i32 */
> - op = copy_op(begin_op, op, INDEX_op_st_i32);
> - op = copy_op(begin_op, op, INDEX_op_st_i32);
> - } else {
> - /* st_i64 */
> - op = copy_op(begin_op, op, INDEX_op_st_i64);
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_add_i64(TCGOp **begin_op, TCGOp *op, uint64_t v)
> -{
> - if (TCG_TARGET_REG_BITS == 32) {
> - /* all 32-bit backends must implement add2_i32 */
> - g_assert(TCG_TARGET_HAS_add2_i32);
> - op = copy_op(begin_op, op, INDEX_op_add2_i32);
> - op->args[4] = tcgv_i32_arg(tcg_constant_i32(v));
> - op->args[5] = tcgv_i32_arg(tcg_constant_i32(v >> 32));
> - } else {
> - op = copy_op(begin_op, op, INDEX_op_add_i64);
> - op->args[2] = tcgv_i64_arg(tcg_constant_i64(v));
> - }
> - return op;
> -}
> -
> -static TCGOp *copy_mul_i32(TCGOp **begin_op, TCGOp *op, uint32_t v)
> -{
> - op = copy_op(begin_op, op, INDEX_op_mul_i32);
> - op->args[2] = tcgv_i32_arg(tcg_constant_i32(v));
> - return op;
> -}
> -
> -static TCGOp *copy_call(TCGOp **begin_op, TCGOp *op, void *func, int *cb_idx)
> -{
> - TCGOp *old_op;
> - int func_idx;
> -
> - /* copy all ops until the call */
> - do {
> - op = copy_op_nocheck(begin_op, op);
> - } while (op->opc != INDEX_op_call);
> -
> - /* fill in the op call */
> - old_op = *begin_op;
> - TCGOP_CALLI(op) = TCGOP_CALLI(old_op);
> - TCGOP_CALLO(op) = TCGOP_CALLO(old_op);
> - tcg_debug_assert(op->life == 0);
> -
> - func_idx = TCGOP_CALLO(op) + TCGOP_CALLI(op);
> - *cb_idx = func_idx;
> - op->args[func_idx] = (uintptr_t)func;
> -
> - return op;
> -}
> -
> -static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
> - TCGOp *begin_op, TCGOp *op,
> - int *unused)
> -{
> - char *ptr = cb->inline_insn.entry.score->data->data;
> - size_t elem_size = g_array_get_element_size(
> - cb->inline_insn.entry.score->data);
> - size_t offset = cb->inline_insn.entry.offset;
> -
> - op = copy_ld_i32(&begin_op, op);
> - op = copy_mul_i32(&begin_op, op, elem_size);
> - op = copy_ext_i32_ptr(&begin_op, op);
> - op = copy_const_ptr(&begin_op, op, ptr + offset);
> - op = copy_add_ptr(&begin_op, op);
> - op = copy_ld_i64(&begin_op, op);
> - op = copy_add_i64(&begin_op, op, cb->inline_insn.imm);
> - op = copy_st_i64(&begin_op, op);
> - return op;
> -}
> -
> -static TCGOp *append_mem_cb(const struct qemu_plugin_dyn_cb *cb,
> - TCGOp *begin_op, TCGOp *op, int *cb_idx)
> -{
> - enum plugin_gen_cb type = begin_op->args[1];
> -
> - tcg_debug_assert(type == PLUGIN_GEN_CB_MEM);
> -
> - /* const_i32 == mov_i32 ("info", so it remains as is) */
> - op = copy_op(&begin_op, op, INDEX_op_mov_i32);
> -
> - /* const_ptr */
> - op = copy_const_ptr(&begin_op, op, cb->userp);
> -
> - /* copy the ld_i32, but note that we only have to copy it once */
> - if (*cb_idx == -1) {
> - op = copy_op(&begin_op, op, INDEX_op_ld_i32);
> - } else {
> - begin_op = QTAILQ_NEXT(begin_op, link);
> - tcg_debug_assert(begin_op && begin_op->opc == INDEX_op_ld_i32);
> - }
> -
> - if (type == PLUGIN_GEN_CB_MEM) {
> - /* call */
> - op = copy_call(&begin_op, op, cb->regular.f.vcpu_udata, cb_idx);
> - }
> -
> - return op;
> -}
> -
> -typedef TCGOp *(*inject_fn)(const struct qemu_plugin_dyn_cb *cb,
> - TCGOp *begin_op, TCGOp *op, int *intp);
> -typedef bool (*op_ok_fn)(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb);
> -
> -static bool op_rw(const TCGOp *op, const struct qemu_plugin_dyn_cb *cb)
> -{
> - int w;
> -
> - w = op->args[2];
> - return !!(cb->rw & (w + 1));
> -}
> -
> -static void inject_cb_type(const GArray *cbs, TCGOp *begin_op,
> - inject_fn inject, op_ok_fn ok)
> -{
> - TCGOp *end_op;
> - TCGOp *op;
> - int cb_idx = -1;
> - int i;
> -
> - if (!cbs || cbs->len == 0) {
> - rm_ops(begin_op);
> - return;
> - }
> -
> - end_op = find_op(begin_op, INDEX_op_plugin_cb_end);
> - tcg_debug_assert(end_op);
> -
> - op = end_op;
> - for (i = 0; i < cbs->len; i++) {
> - struct qemu_plugin_dyn_cb *cb =
> - &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
> -
> - if (!ok(begin_op, cb)) {
> - continue;
> - }
> - op = inject(cb, begin_op, op, &cb_idx);
> - }
> - rm_ops_range(begin_op, end_op);
> -}
> -
> -static void
> -inject_inline_cb(const GArray *cbs, TCGOp *begin_op, op_ok_fn ok)
> -{
> - inject_cb_type(cbs, begin_op, append_inline_cb, ok);
> -}
> -
> -static void
> -inject_mem_cb(const GArray *cbs, TCGOp *begin_op)
> -{
> - inject_cb_type(cbs, begin_op, append_mem_cb, op_rw);
> -}
> -
> /* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
> void plugin_gen_disable_mem_helpers(void)
> {
> @@ -451,23 +124,6 @@ void plugin_gen_disable_mem_helpers(void)
> }
> }
>
> -static void plugin_gen_mem_regular(const struct qemu_plugin_tb *ptb,
> - TCGOp *begin_op, int insn_idx)
> -{
> - struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
> - inject_mem_cb(insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR], begin_op);
> -}
> -
> -static void plugin_gen_mem_inline(const struct qemu_plugin_tb *ptb,
> - TCGOp *begin_op, int insn_idx)
> -{
> - const GArray *cbs;
> - struct qemu_plugin_insn *insn = g_ptr_array_index(ptb->insns, insn_idx);
> -
> - cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
> - inject_inline_cb(cbs, begin_op, op_rw);
> -}
> -
> static void gen_enable_mem_helper(struct qemu_plugin_tb *ptb,
> struct qemu_plugin_insn *insn)
> {
> @@ -557,6 +213,21 @@ static void gen_inline_cb(struct qemu_plugin_dyn_cb *cb)
> tcg_temp_free_ptr(ptr);
> }
>
> +static void gen_mem_cb(struct qemu_plugin_dyn_cb *cb,
> + qemu_plugin_meminfo_t meminfo, TCGv_i64 addr)
> +{
> + TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
> +
> + tcg_gen_ld_i32(cpu_index, tcg_env,
> + -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
> + tcg_gen_call4(cb->regular.f.vcpu_mem, cb->regular.info, NULL,
> + tcgv_i32_temp(cpu_index),
> + tcgv_i32_temp(tcg_constant_i32(meminfo)),
> + tcgv_i64_temp(addr),
> + tcgv_ptr_temp(tcg_constant_ptr(cb->userp)));
> + tcg_temp_free_i32(cpu_index);
> +}
> +
> /* #define DEBUG_PLUGIN_GEN_OPS */
> static void pr_ops(void)
> {
> @@ -705,34 +376,43 @@ static void plugin_gen_inject(struct qemu_plugin_tb *plugin_tb)
> break;
> }
>
> - case INDEX_op_plugin_cb_start:
> + case INDEX_op_plugin_mem_cb:
> {
> - enum plugin_gen_from from = op->args[0];
> - enum plugin_gen_cb type = op->args[1];
> + TCGv_i64 addr = temp_tcgv_i64(arg_temp(op->args[0]));
> + qemu_plugin_meminfo_t meminfo = op->args[1];
> + struct qemu_plugin_insn *insn;
> + const GArray *cbs;
> + int i, n, rw;
>
> - switch (from) {
> - case PLUGIN_GEN_FROM_MEM:
> - {
> - g_assert(insn_idx >= 0);
> + assert(insn_idx >= 0);
> + insn = g_ptr_array_index(plugin_tb->insns, insn_idx);
> + rw = qemu_plugin_mem_is_store(meminfo) ? 2 : 1;
>
> - switch (type) {
> - case PLUGIN_GEN_CB_MEM:
> - plugin_gen_mem_regular(plugin_tb, op, insn_idx);
> - break;
> - case PLUGIN_GEN_CB_INLINE:
> - plugin_gen_mem_inline(plugin_tb, op, insn_idx);
> - break;
> - default:
> - g_assert_not_reached();
> + tcg_ctx->emit_before_op = op;
> +
> + cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR];
> + for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
> + struct qemu_plugin_dyn_cb *cb =
> + &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
> + if (cb->rw & rw) {
> + gen_mem_cb(cb, meminfo, addr);
> }
> + }
>
> - break;
> - }
> - default:
> - g_assert_not_reached();
> + cbs = insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE];
> + for (i = 0, n = (cbs ? cbs->len : 0); i < n; i++) {
> + struct qemu_plugin_dyn_cb *cb =
> + &g_array_index(cbs, struct qemu_plugin_dyn_cb, i);
> + if (cb->rw & rw) {
> + gen_inline_cb(cb);
> + }
> }
> +
> + tcg_ctx->emit_before_op = NULL;
> + tcg_op_remove(tcg_ctx, op);
> break;
> }
> +
> default:
> /* plugins don't care about any other ops */
> break;
> diff --git a/tcg/tcg-op-ldst.c b/tcg/tcg-op-ldst.c
> index f11043b449..8510160258 100644
> --- a/tcg/tcg-op-ldst.c
> +++ b/tcg/tcg-op-ldst.c
> @@ -161,14 +161,14 @@ plugin_gen_mem_callbacks(TCGv_i64 copy_addr, TCGTemp *orig_addr, MemOpIdx oi,
> copy_addr = tcg_temp_ebb_new_i64();
> tcg_gen_extu_i32_i64(copy_addr, temp_tcgv_i32(orig_addr));
> }
> - plugin_gen_empty_mem_callback(copy_addr, info);
> + tcg_gen_plugin_mem_cb(copy_addr, info);
> tcg_temp_free_i64(copy_addr);
> } else {
> if (copy_addr) {
> - plugin_gen_empty_mem_callback(copy_addr, info);
> + tcg_gen_plugin_mem_cb(copy_addr, info);
> tcg_temp_free_i64(copy_addr);
> } else {
> - plugin_gen_empty_mem_callback(temp_tcgv_i64(orig_addr), info);
> + tcg_gen_plugin_mem_cb(temp_tcgv_i64(orig_addr), info);
> }
> }
> }
> diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
> index 0f2026c91c..0ae12fa49d 100644
> --- a/tcg/tcg-op.c
> +++ b/tcg/tcg-op.c
> @@ -317,6 +317,11 @@ void tcg_gen_plugin_cb(unsigned from)
> tcg_gen_op1(INDEX_op_plugin_cb, from);
> }
>
> +void tcg_gen_plugin_mem_cb(TCGv_i64 addr, unsigned meminfo)
> +{
> + tcg_gen_op2(INDEX_op_plugin_mem_cb, tcgv_i64_arg(addr), meminfo);
> +}
> +
> void tcg_gen_plugin_cb_start(unsigned from, unsigned type, unsigned wr)
> {
> tcg_gen_op3(INDEX_op_plugin_cb_start, from, type, wr);
Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
next prev parent reply other threads:[~2024-03-19 13:35 UTC|newest]
Thread overview: 57+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-03-16 1:56 [PATCH 00/22] plugins: Rewrite plugin code generation Richard Henderson
2024-03-16 1:56 ` [PATCH 01/22] tcg: Add TCGContext.emit_before_op Richard Henderson
2024-03-19 10:55 ` Pierrick Bouvier
2024-03-19 14:04 ` Alex Bennée
2024-03-19 21:23 ` Richard Henderson
2024-03-16 1:57 ` [PATCH 02/22] tcg: Make tcg/helper-info.h self-contained Richard Henderson
2024-03-18 10:01 ` Alex Bennée
2024-03-18 10:03 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 03/22] tcg: Pass function pointer to tcg_gen_call* Richard Henderson
2024-03-18 10:02 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 04/22] plugins: Zero new qemu_plugin_dyn_cb entries Richard Henderson
2024-03-18 10:03 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 05/22] plugins: Move function pointer in qemu_plugin_dyn_cb Richard Henderson
2024-03-18 10:04 ` Alex Bennée
2024-03-19 13:18 ` Pierrick Bouvier
2024-03-19 21:30 ` Richard Henderson
2024-03-20 5:31 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 06/22] plugins: Create TCGHelperInfo for all out-of-line callbacks Richard Henderson
2024-03-19 13:12 ` Pierrick Bouvier
2024-03-19 19:51 ` Richard Henderson
2024-03-20 5:22 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 07/22] plugins: Use emit_before_op for PLUGIN_GEN_AFTER_INSN Richard Henderson
2024-03-19 13:32 ` Pierrick Bouvier
2024-03-19 19:56 ` Richard Henderson
2024-03-20 5:36 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 08/22] plugins: Use emit_before_op for PLUGIN_GEN_FROM_TB Richard Henderson
2024-03-19 13:22 ` Pierrick Bouvier
2024-03-19 19:57 ` Richard Henderson
2024-03-16 1:57 ` [PATCH 09/22] plugins: Add PLUGIN_GEN_AFTER_TB Richard Henderson
2024-03-19 13:33 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 10/22] plugins: Use emit_before_op for PLUGIN_GEN_FROM_INSN Richard Henderson
2024-03-19 13:34 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 11/22] plugins: Use emit_before_op for PLUGIN_GEN_FROM_MEM Richard Henderson
2024-03-19 13:35 ` Pierrick Bouvier [this message]
2024-03-16 1:57 ` [PATCH 12/22] plugins: Remove plugin helpers Richard Henderson
2024-03-18 16:38 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 13/22] tcg: Remove TCG_CALL_PLUGIN Richard Henderson
2024-03-19 13:06 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 14/22] tcg: Remove INDEX_op_plugin_cb_{start,end} Richard Henderson
2024-03-19 13:04 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 15/22] plugins: Simplify callback queues Richard Henderson
2024-03-19 13:28 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 16/22] plugins: Introduce PLUGIN_CB_MEM_REGULAR Richard Henderson
2024-03-19 13:28 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 17/22] plugins: Replace pr_ops with a proper debug dump flag Richard Henderson
2024-03-19 12:59 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 18/22] plugins: Split out common cb expanders Richard Henderson
2024-03-19 13:29 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 19/22] plugins: Merge qemu_plugin_tb_insn_get to plugin-gen.c Richard Henderson
2024-03-19 13:30 ` Pierrick Bouvier
2024-03-16 1:57 ` [PATCH 20/22] plugins: Move qemu_plugin_insn_cleanup_fn to tcg.c Richard Henderson
2024-03-18 17:44 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 21/22] plugins: Inline plugin_gen_empty_callback Richard Henderson
2024-03-18 19:09 ` Alex Bennée
2024-03-16 1:57 ` [PATCH 22/22] plugins: Update the documentation block for plugin-gen.c Richard Henderson
2024-03-19 12:56 ` Pierrick Bouvier
2024-03-19 13:38 ` [PATCH 00/22] plugins: Rewrite plugin code generation Pierrick Bouvier
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=21bbcdb3-16a2-4cd5-adb1-a42733866d63@linaro.org \
--to=pierrick.bouvier@linaro.org \
--cc=alex.bennee@linaro.org \
--cc=qemu-devel@nongnu.org \
--cc=richard.henderson@linaro.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.