Re: [PATCH v6 03/13] perf annotate: Handle absolute addressing in data type profiling

From: Arnaldo Carvalho de Melo

Date: Wed Nov 18 2026 - 11:15:41 EST


On Tue, Nov 17, 2026 at 11:08:40PM -0800, Namhyung Kim wrote:
> On Tue, Nov 17, 2026 at 05:04:21PM -0300, Arnaldo Carvalho de Melo wrote:
> > From: Arnaldo Carvalho de Melo <acme@xxxxxxxxxx>
> >
> > 32-bit x86 accesses globals with absolute addresses, like
> > "movl %eax,0x8c73448", but the operand parser only recognized the
> > offset(reg) forms, so the operand had no memory reference, the resolver
> > saw a zero data address and resolved nothing.
> >
> > Parse a bare "0x" number as an absolute memory operand, leaving jumps,
> > calls, loop* and the 64-bit movabs* out, use the address in the resolver,
> > and let the instruction tracking record the type of an absolute global
> > load in the destination register. The displacement is sign extended for
> > 64-bit objects, as the CPU does, and zero extended for 32-bit ones.
> > Values that do not fit the int offset, zero, and the operands of
> > relocatable objects, which are unrelocated addends, are skipped.
> >
> > With bare numbers being memory operands, a frame base register of -1,
> > "none", would also compare equal to the -1 "no register" of an absolute
> > operand and take it for a stack access, so guard those comparisons.
> > Operands left with no register, like a user space "%gs:imm", are no
> > longer looked up as variables, which can change the data type stats of
> > those samples.
> >
> > Signed-off-by: Arnaldo Carvalho de Melo <acme@xxxxxxxxxx>
> > ---
> > tools/perf/util/annotate-arch/annotate-x86.c | 52 ++++++++++++++++++--
> > tools/perf/util/annotate.c | 25 +++++++++-
> > tools/perf/util/annotate.h | 7 +++
> > 3 files changed, 79 insertions(+), 5 deletions(-)
> >
> > diff --git a/tools/perf/util/annotate-arch/annotate-x86.c b/tools/perf/util/annotate-arch/annotate-x86.c
> > index e38a4e7a54d5585c..adb52d148cba6001 100644
> > --- a/tools/perf/util/annotate-arch/annotate-x86.c
> > +++ b/tools/perf/util/annotate-arch/annotate-x86.c
> > @@ -230,6 +230,11 @@ static bool vtable_get_rettype(Dwarf_Die *class_die, int offset,
> > return die_get_real_type(&func_die, type_die) != NULL;
> > }
> >
> > +static bool is_stack_or_fb_reg(struct type_state *state, int fbreg, int reg)
> > +{
> > + return (fbreg != -1 && reg == fbreg) || reg == state->stack_reg;
> > +}
> > +
> > static void update_insn_state_x86(struct type_state *state,
> > struct data_loc_info *dloc, Dwarf_Die *cu_die,
> > struct disasm_line *dl)
> > @@ -437,7 +442,7 @@ static void update_insn_state_x86(struct type_state *state,
> > invalidate_reg_state(tsr);
> >
> > /* Case 1: Based on stack pointer or frame pointer */
> > - if (sreg == fbreg || sreg == state->stack_reg) {
> > + if (is_stack_or_fb_reg(state, fbreg, sreg)) {
> > struct type_state_stack *stack;
> > int offset = src->offset - fboff;
> >
> > @@ -626,7 +631,7 @@ static void update_insn_state_x86(struct type_state *state,
> >
> > retry:
> > /* Check stack variables with offset */
> > - if (sreg == fbreg || sreg == state->stack_reg) {
> > + if (is_stack_or_fb_reg(state, fbreg, sreg)) {
> > struct type_state_stack *stack;
> > int offset = src->offset - fboff;
> >
> > @@ -741,6 +746,29 @@ static void update_insn_state_x86(struct type_state *state,
> > insn_offset, addr, dst->reg1);
> > pr_debug_type_name(&type_die, tsr->kind);
> > }
> > + /* Or an absolute address, as used by 32-bit code */
> > + else if (annotated_op_loc__is_abs(src, map__dso(dloc->ms->map))) {
>
> Then shouldn't it check if it's actually 32-bit code?

After some more rounds of local reviews and trying to answer your
question:
/*
* Keep only what fits the int, as disp32 or as a u32;
- * movabs*, the 64-bit form, is left out.
+ * a 64-bit absolute value is left out. The LLVM
+ * disassembler prints a disp32 that does not fit an
+ * int as a negative number.
*/
if (offset != 0 && (offset <= UINT_MAX ||
(s64)(int)offset == (s64)offset)) {
- /* Absolute address, as used by 32-bit code */
+ /* An absolute address: 32-bit code, or a 64-bit disp32 */
op_loc->mem_ref = true;
op_loc->offset = offset;
}

It is not 32-bit specific, the comment was wrong.

> > + struct map_symbol *ms = dloc->ms;
> > + u64 ip = ms->sym->start + dl->al.offset;
> > + u64 addr = annotated_op_loc__abs_addr(src, map__dso(ms->map));
> > + int offset;
> > +
> > + if (!get_global_var_type(cu_die, dloc, ip, addr, &offset,
> > + &type_die) ||
> > + !die_get_member_type(&type_die, offset, &type_die)) {
> > + invalidate_reg_state(tsr);
> > + return;
> > + }
> > +
> > + tsr->type = type_die;
> > + tsr->kind = TSR_KIND_TYPE;

> I'm not sure if it's _TYPE at this point. Probably _POINTER instead?

Why do you think so?

This is just duplicating to some degree what is right before, that uses
a TYPE for a global, no? But please check v7, there is a change in this
area.

- Arnaldo