Re: [PATCH v6 03/13] perf annotate: Handle absolute addressing in data type profiling
From: Namhyung Kim
Date: Wed Nov 18 2026 - 02:08:49 EST
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?
> + 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?
> + tsr->offset = 0;
> + tsr->ok = true;
> +
> + pr_debug_dtp("mov [%x] global addr=%#"PRIx64" -> reg%d",
> + insn_offset, addr, dst->reg1);
> + pr_debug_type_name(&type_die, tsr->kind);
> + }
> /* And check percpu access with base register */
> else if (has_reg_type(state, sreg) &&
> state->regs[sreg].kind == TSR_KIND_PERCPU_BASE) {
> @@ -827,7 +855,7 @@ static void update_insn_state_x86(struct type_state *state,
> /* Case 3. register to memory transfers */
> if (!src->mem_ref && dst->mem_ref) {
> /* Check stack variables with offset */
> - if (dst->reg1 == fbreg || dst->reg1 == state->stack_reg) {
> + if (is_stack_or_fb_reg(state, fbreg, dst->reg1)) {
> struct type_state_stack *stack;
> int offset = dst->offset - fboff;
>
> @@ -931,7 +959,7 @@ static int extract_reg_offset(const struct arch *arch, const char *str,
> }
>
> static void extract_op_location_x86(const struct arch *arch,
> - struct disasm_line *dl __maybe_unused,
> + struct disasm_line *dl,
> const char *op_str, int op_idx __maybe_unused,
> struct annotated_op_loc *op_loc)
> {
> @@ -960,6 +988,22 @@ static void extract_op_location_x86(const struct arch *arch,
> op_loc->offset = strtol(s + 1, &p, 0);
> if (p && p != s + 1)
> op_loc->imm = true;
> + } else if (!strncmp(s, "0x", 2) && !ins__is_jump(&dl->ins) &&
> + !ins__is_call(&dl->ins) &&
> + strncmp(dl->ins.name, "loop", 4) &&
> + strncmp(dl->ins.name, "movabs", 6)) {
> + u64 offset = strtoull(s, NULL, 0);
> +
> + /*
> + * Keep only what fits the int, as disp32 or as a u32;
> + * movabs*, the 64-bit form, is left out.
> + */
> + if (offset != 0 && (offset <= UINT_MAX ||
> + (s64)(int)offset == (s64)offset)) {
> + /* Absolute address, as used by 32-bit code */
> + op_loc->mem_ref = true;
I don't think it's a mem-ref.
Thanks,
Namhyung
> + op_loc->offset = offset;
> + }
> }
> }
> }
> diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
> index 86a4beec6528e9bd..f33e22c20656a4f3 100644
> --- a/tools/perf/util/annotate.c
> +++ b/tools/perf/util/annotate.c
> @@ -2605,6 +2605,21 @@ int arch__dwarf_regnum(const struct arch *arch, const char *str)
> return reg < 0 ? -1 : reg;
> }
>
> +/* A relocatable object's operand is an unrelocated addend, not an address */
> +bool annotated_op_loc__is_abs(const struct annotated_op_loc *op_loc,
> + const struct dso *dso)
> +{
> + return !dso__rel(dso) && op_loc->mem_ref && op_loc->reg1 == -1 && op_loc->reg2 == -1 &&
> + op_loc->segment == INSN_SEG_NONE && op_loc->offset != 0;
> +}
> +
> +/* The disp32 of a 64-bit object is sign extended, a 32-bit one is not */
> +u64 annotated_op_loc__abs_addr(const struct annotated_op_loc *op_loc,
> + const struct dso *dso)
> +{
> + return dso__is_64_bit(dso) ? (u64)(s64)op_loc->offset : (u32)op_loc->offset;
> +}
> +
> /**
> * annotate_get_insn_location - Get location of instruction
> * @arch: the architecture info
> @@ -2622,7 +2637,7 @@ int arch__dwarf_regnum(const struct arch *arch, const char *str)
> * mov (%rax), %rcx # src_reg1 = rax, src_mem = 1, src_offset = 0
> * # dst_reg1 = rcx, dst_mem = 0
> *
> - * mov 0x18, %r8 # src_reg1 = -1, src_mem = 0
> + * mov 0x18, %r8 # src_reg1 = -1, src_mem = 1, src_offset = 0x18
> * # dst_reg1 = r8, dst_mem = 0
> *
> * mov %rsi, 8(%rbx,%rcx,4) # src_reg1 = rsi, src_mem = 0, src_multi_regs = 0
> @@ -2894,6 +2909,11 @@ __hist_entry__get_data_type(struct hist_entry *he, const struct arch *arch,
> dloc.var_addr = annotate_calc_pcrel(ms, dloc.ip,
> op_loc->offset, dl);
> }
> + /* Absolute addressing, as used by 32-bit code */
> + else if (annotated_op_loc__is_abs(op_loc, map__dso(ms->map))) {
> + dloc.var_addr = annotated_op_loc__abs_addr(op_loc, map__dso(ms->map));
> + op_loc->reg1 = DWARF_REG_PC;
> + }
>
> /* This CPU access in kernel - pretend PC-relative addressing */
> if (dso__kernel(map__dso(ms->map)) && arch__is_x86(arch) &&
> @@ -2902,6 +2922,9 @@ __hist_entry__get_data_type(struct hist_entry *he, const struct arch *arch,
> op_loc->reg1 = DWARF_REG_PC;
> }
>
> + if (op_loc->reg1 == -1)
> + continue;
> +
> mem_type = find_data_type(&dloc);
>
> if (mem_type == NULL && is_stack_canary(arch, op_loc)) {
> diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
> index 1b47c1156b9a72e1..1b0991d4e98c911e 100644
> --- a/tools/perf/util/annotate.h
> +++ b/tools/perf/util/annotate.h
> @@ -18,6 +18,7 @@
> #include "branch.h"
> #include "evsel.h"
>
> +struct dso;
> struct hist_browser_timer;
> struct hist_entry;
> struct map;
> @@ -638,6 +639,12 @@ struct annotated_insn_loc {
> i < INSN_OP_MAX; \
> i++, op_loc++)
>
> +/* Bare number operand, as used by 32-bit code to access globals */
> +bool annotated_op_loc__is_abs(const struct annotated_op_loc *op_loc,
> + const struct dso *dso);
> +u64 annotated_op_loc__abs_addr(const struct annotated_op_loc *op_loc,
> + const struct dso *dso);
> +
> /* Get detailed location info in the instruction */
> int annotate_get_insn_location(const struct arch *arch, struct disasm_line *dl,
> struct annotated_insn_loc *loc);
> --
> 2.56.0
>