Skip to content

Commit

Permalink
Change from instr = ... + dt_irlist_append(...) to emit*(...)
Browse files Browse the repository at this point in the history 
BPF instructions were being generated using a pair of statements,
first creating the instruction code, and then appending it to the IR
list.  The append operation would specify an optional label.  For
some instructions an external identifier might be associated with the
last appended instruction.

So, a code fragment may look like this:

    instr = BPF_CALL_FUNC(idp->di_id);
    dt_irlist_append(dlp, dt_cg_node_alloc(lbl_call, instr));
    dlp->dl_last->di_extern = idp;
    instr = BPF_RETURN();
    dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));

We introduce four macros to rewrite this (and more complex) code:

    emit(dlp, instr)
        Emit a BPF instruction (instr) in the given IR list (dlp).
    emite(dlp, instr, idp)
        Emit a BPF instruction (instr) in the given IR list (dlp)
        and associate an external identifier (idp) with it.
    emitl(dlp, lbl, instr)
        Emit a labelled BPF instruction (instr) in the given IR
        list (dlp).
    emitle(dlp, lbl, instr, idp)
        Emit a labelled BPF instruction (instr) in the given IR
        list (dlp) and associate an external identifier (idp) with
        it.

With these new macros, the code shown above becomes:

    emitle(dlp, lbl_call,
                BPF_CALL_FUNC(idp->di_id), idp);
    emit(dlp,   BPF_RETURN());

Signed-off-by: Eugene Loh <eugene.loh@oracle.com>
Signed-off-by: Kris Van Hees <kris.van.hees@oracle.com>
Reviewed-by: Eugene Loh <eugene.loh@oracle.com>
Reviewed-by: Kris Van Hees <kris.van.hees@oracle.com>
  • Loading branch information
@kvanhees
kvanhees committed Dec 3, 2020
1 parent 85c8512 commit e0e51ae
Show file tree
Hide file tree
Showing 8 changed files with 365 additions and 717 deletions.
5 changes: 5 additions & 0 deletions libdtrace/Build
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,11 @@ dt_debug.c_CFLAGS := -Wno-prio-ctor-dtor
dt_cg.c_CFLAGS := -Wno-pedantic
dt_dis.c_CFLAGS := -Wno-pedantic
dt_proc.c_CFLAGS := -Wno-pedantic
dt_prov_dtrace.c_CFLAGS := -Wno-pedantic
dt_prov_fbt.c_CFLAGS := -Wno-pedantic
dt_prov_profile.c_CFLAGS := -Wno-pedantic
dt_prov_sdt.c_CFLAGS := -Wno-pedantic
dt_prov_syscall.c_CFLAGS := -Wno-pedantic

# Extra include path for this file
dt_bpf.c_CFLAGS := -Ilibbpf
Expand Down
13 changes: 13 additions & 0 deletions libdtrace/dt_as.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,19 @@ extern void dt_irlist_destroy(dt_irlist_t *);
extern void dt_irlist_append(dt_irlist_t *, dt_irnode_t *);
extern uint_t dt_irlist_label(dt_irlist_t *);

#define emitle(dlp, lbl, instr, idp) \
({ \
dt_irnode_t *dip = dt_cg_node_alloc((lbl), (instr)); \
dt_irlist_append((dlp), dip); \
if (idp != NULL) \
dip->di_extern = (idp); \
dip; \
})
#define emite(dlp, instr, idp) emitle((dlp), DT_LBL_NONE, (instr), (idp))
#define emitl(dlp, lbl, instr) emitle((dlp), (lbl), (instr), NULL)
#define emit(dlp, instr) emitle((dlp), DT_LBL_NONE, (instr), NULL)


#ifdef __cplusplus
}
#endif
Expand Down
857 changes: 281 additions & 576 deletions libdtrace/dt_cg.c
View file

Large diffs are not rendered by default.

84 changes: 27 additions & 57 deletions libdtrace/dt_prov_dtrace.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -74,7 +74,6 @@ static void trampoline(dt_pcb_t *pcb)
{
int i;
dt_irlist_t *dlp = &pcb->pcb_ir;
struct bpf_insn instr;
uint_t lbl_exit;
dt_activity_t act;
int adv_act;
Expand Down Expand Up @@ -135,26 +134,16 @@ static void trampoline(dt_pcb_t *pcb)
*/
dt_ident_t *state = dt_dlib_get_map(pcb->pcb_hdl, "state");

instr = BPF_STORE_IMM(BPF_W, BPF_REG_FP, DT_STK_SPILL(0), key);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_CALL_HELPER(BPF_FUNC_get_smp_processor_id);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_W, BPF_REG_FP, DT_STK_SPILL(1),
BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_STORE_IMM(BPF_W, BPF_REG_FP, DT_STK_SPILL(0), key));
emit(dlp, BPF_CALL_HELPER(BPF_FUNC_get_smp_processor_id));
emit(dlp, BPF_STORE(BPF_W, BPF_REG_FP, DT_STK_SPILL(1), BPF_REG_0));
dt_cg_xsetx(dlp, state, DT_LBL_NONE, BPF_REG_1, state->di_id);
instr = BPF_MOV_REG(BPF_REG_2, BPF_REG_FP);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, DT_STK_SPILL(0));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_MOV_REG(BPF_REG_3, BPF_REG_FP);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, DT_STK_SPILL(1));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_MOV_IMM(BPF_REG_4, BPF_ANY);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_CALL_HELPER(BPF_FUNC_map_update_elem);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_MOV_REG(BPF_REG_2, BPF_REG_FP));
emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, DT_STK_SPILL(0)));
emit(dlp, BPF_MOV_REG(BPF_REG_3, BPF_REG_FP));
emit(dlp, BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, DT_STK_SPILL(1)));
emit(dlp, BPF_MOV_IMM(BPF_REG_4, BPF_ANY));
emit(dlp, BPF_CALL_HELPER(BPF_FUNC_map_update_elem));
}

/*
Expand All @@ -165,10 +154,8 @@ static void trampoline(dt_pcb_t *pcb)
* // (%r8 = dctx->ctx)
* // lddw %r8, [%fp + DCTX_FP(DCTX_CTX)]
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST)));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX)));

#if 0
/*
Expand All @@ -180,10 +167,8 @@ static void trampoline(dt_pcb_t *pcb)
* // (...)
*/
for (i = 0; i < sizeof(dt_pt_regs); i += 8) {
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0));
}
#endif

Expand All @@ -207,39 +192,24 @@ static void trampoline(dt_pcb_t *pcb)
* // lddw %r0, [%r8 + PT_REGS_ARG5]
* // stdw [%r7 + DMST_ARG(5)], %r0
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG1);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(1), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG2);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(2), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG3);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(3), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG4);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(4), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG5);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(5), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG0));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG1));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(1), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG2));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(2), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG3));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(3), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG4));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(4), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG5));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(5), BPF_REG_0));

/*
* (we clear dctx->mst->argv[6] and on)
*/
for (i = 6; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++) {
instr = BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)),
0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
}
for (i = 6; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++)
emit(dlp, BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)), 0));

if (adv_act)
dt_cg_tramp_epilogue_advance(pcb, lbl_exit, act);
Expand Down
56 changes: 18 additions & 38 deletions libdtrace/dt_prov_fbt.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -163,7 +163,6 @@ static void trampoline(dt_pcb_t *pcb)
{
int i;
dt_irlist_t *dlp = &pcb->pcb_ir;
struct bpf_insn instr;
uint_t lbl_exit;

lbl_exit = dt_cg_tramp_prologue(pcb);
Expand All @@ -176,20 +175,16 @@ static void trampoline(dt_pcb_t *pcb)
* // (%r8 = dctx->ctx)
* // lddw %r8, [%fp + DCTX_FP(DCTX_CTX)]
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST)));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX)));

#if 0
/*
* dctx->mst->regs = *(dt_pt_regs *)dctx->ctx;
*/
for (i = 0; i < sizeof(dt_pt_regs); i += 8) {
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0));
}
#endif

Expand All @@ -213,39 +208,24 @@ static void trampoline(dt_pcb_t *pcb)
* // lddw %r0, [%r8 + PT_REGS_ARG5]
* // stdw [%r7 + DMST_ARG(5)], %r0
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG1);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(1), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG2);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(2), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG3);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(3), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG4);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(4), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG5);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(5), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG0));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG1));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(1), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG2));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(2), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG3));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(3), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG4));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(4), BPF_REG_0));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_ARG5));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(5), BPF_REG_0));

/*
* (we clear dctx->mst->argv[6] and on)
*/
for (i = 6; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++) {
instr = BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)),
0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
}
for (i = 6; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++)
emit(dlp, BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)), 0));

dt_cg_tramp_epilogue(pcb, lbl_exit);
}
Expand Down
26 changes: 8 additions & 18 deletions libdtrace/dt_prov_profile.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -217,7 +217,6 @@ static void trampoline(dt_pcb_t *pcb)
{
int i;
dt_irlist_t *dlp = &pcb->pcb_ir;
struct bpf_insn instr;
uint_t lbl_exit;

lbl_exit = dt_cg_tramp_prologue(pcb);
Expand All @@ -230,10 +229,8 @@ static void trampoline(dt_pcb_t *pcb)
* // (%r8 = dctx->ctx)
* // lddw %r8, [%fp + DCTX_FP(DCTX_CTX)]
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST)));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX)));

#if 0
/*
Expand All @@ -243,10 +240,8 @@ static void trampoline(dt_pcb_t *pcb)
* // copy *(dt_pt_regs *)dctx->ctx)
*/
for (i = 0; i < sizeof(dt_pt_regs); i += 8) {
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, i));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_REGS + i, BPF_REG_0));
}
#endif

Expand All @@ -266,19 +261,14 @@ static void trampoline(dt_pcb_t *pcb)
* // lddw %r0, [%r8 + PT_REGS_IP]
* // stdw [%r7 + DMST_ARG(0)], %r0
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_IP);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_0, BPF_REG_8, PT_REGS_IP));
emit(dlp, BPF_STORE(BPF_DW, BPF_REG_7, DMST_ARG(0), BPF_REG_0));

/*
* (we clear dctx->mst->argv[1] and on)
*/
for (i = 1; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++) {
instr = BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)),
0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
}
for (i = 1; i < ARRAY_SIZE(((dt_mstate_t *)0)->argv); i++)
emit(dlp, BPF_STORE_IMM(BPF_DW, BPF_REG_7, DCTX_FP(DMST_ARG(i)), 0));

dt_cg_tramp_epilogue(pcb, lbl_exit);
}
Expand Down
16 changes: 5 additions & 11 deletions libdtrace/dt_prov_sdt.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -395,7 +395,6 @@ static void trampoline(dt_pcb_t *pcb)
{
int i;
dt_irlist_t *dlp = &pcb->pcb_ir;
struct bpf_insn instr;
uint_t lbl_exit;

lbl_exit = dt_cg_tramp_prologue(pcb);
Expand All @@ -408,10 +407,8 @@ static void trampoline(dt_pcb_t *pcb)
* // (%r8 = dctx->ctx)
* // lddw %r8, [%fp + DCTX_FP(DCTX_CTX)]
*/
instr = BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
instr = BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX));
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_7, BPF_REG_FP, DCTX_FP(DCTX_MST)));
emit(dlp, BPF_LOAD(BPF_DW, BPF_REG_8, BPF_REG_FP, DCTX_FP(DCTX_CTX)));

#if 0
/*
Expand All @@ -421,8 +418,7 @@ static void trampoline(dt_pcb_t *pcb)
* // (...)
*/
for (i = 0; i < sizeof(dt_pt_regs); i += 8) {
instr = BPF_STORE_IMM(BPF_DW, BPF_REG_7, DMST_REGS + i, 0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
emit(dlp, BPF_STORE_IMM(BPF_DW, BPF_REG_7, DMST_REGS + i, 0));
}
#endif

Expand All @@ -431,10 +427,8 @@ static void trampoline(dt_pcb_t *pcb)
* dctx->mst->argv[i] = 0
* // stdw [%r7 + DMST_ARG(i)], 0
*/
for (i = 0; i < pcb->pcb_pinfo.dtp_argc; i++) {
instr = BPF_STORE_IMM(BPF_DW, BPF_REG_7, DMST_ARG(i), 0);
dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
}
for (i = 0; i < pcb->pcb_pinfo.dtp_argc; i++)
emit(dlp, BPF_STORE_IMM(BPF_DW, BPF_REG_7, DMST_ARG(i), 0));

dt_cg_tramp_epilogue(pcb, lbl_exit);
}
Expand Down

0 comments on commit e0e51ae

Please sign in to comment.