All of lore.kernel.org
 help / color / mirror / Atom feed
From: Namhyung Kim <namhyung@kernel.org>
To: Arnaldo Carvalho de Melo <acme@kernel.org>
Cc: Ingo Molnar <mingo@kernel.org>,
	Thomas Gleixner <tglx@linutronix.de>,
	James Clark <james.clark@linaro.org>,
	Jiri Olsa <jolsa@kernel.org>, Ian Rogers <irogers@google.com>,
	Adrian Hunter <adrian.hunter@intel.com>,
	Clark Williams <williams@redhat.com>,
	linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org,
	Arnaldo Carvalho de Melo <acme@redhat.com>
Subject: Re: [PATCH v6 03/13] perf annotate: Handle absolute addressing in data type profiling
Date: Tue, 17 Nov 2026 23:08:40 -0800	[thread overview]
Message-ID: <av1O-I_uLOoY0u5r@google.com> (raw)
In-Reply-To: <20261117200433.45174-4-acme@kernel.org>

On Tue, Nov 17, 2026 at 05:04:21PM -0300, Arnaldo Carvalho de Melo wrote:
> From: Arnaldo Carvalho de Melo <acme@redhat.com>
> 
> 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@redhat.com>
> ---
>  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
> 

  parent reply	other threads:[~2026-11-18  7:08 UTC|newest]

Thread overview: 30+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17 20:04 [PATCH v6 0/13] perf coverage: A harness for perf, and the fixes it found Arnaldo Carvalho de Melo
2026-11-17 20:04 ` [PATCH v6 01/13] perf jvmti: Link the agent with EXTRA_CFLAGS Arnaldo Carvalho de Melo
2026-11-17 20:10   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 02/13] perf scripts: Add a coverage harness for perf Arnaldo Carvalho de Melo
2026-11-17 20:15   ` sashiko-bot
2026-11-18  6:56   ` Namhyung Kim
2026-11-17 20:04 ` [PATCH v6 03/13] perf annotate: Handle absolute addressing in data type profiling Arnaldo Carvalho de Melo
2026-11-17 20:35   ` sashiko-bot
2026-11-18  7:08   ` Namhyung Kim [this message]
2026-11-17 20:04 ` [PATCH v6 04/13] perf tests: Exercise DW_OP_addrx global variables Arnaldo Carvalho de Melo
2026-11-17 20:13   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 05/13] perf tests: Exercise the flexible array member path Arnaldo Carvalho de Melo
2026-11-17 20:11   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 06/13] perf annotate-data: Count flexible array accesses for the whole struct Arnaldo Carvalho de Melo
2026-11-17 20:10   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 07/13] perf tests: Exercise data type resolution from a register Arnaldo Carvalho de Melo
2026-11-17 20:20   ` sashiko-bot
2026-11-18  7:16   ` Namhyung Kim
2026-11-17 20:04 ` [PATCH v6 08/13] perf annotate: Print the stats after the annotations Arnaldo Carvalho de Melo
2026-11-17 20:11   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 09/13] perf tests: Silence the libbfd probe in build-test Arnaldo Carvalho de Melo
2026-11-17 20:08   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 10/13] perf build: Record the display-only features in FEATURE-DUMP Arnaldo Carvalho de Melo
2026-11-17 20:15   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 11/13] perf tests: Fix the Intel PT virtual LBR check Arnaldo Carvalho de Melo
2026-11-17 20:18   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 12/13] perf test: Drop samples without an IP in the dlfilter test Arnaldo Carvalho de Melo
2026-11-17 20:12   ` sashiko-bot
2026-11-17 20:04 ` [PATCH v6 13/13] perf test: Skip the LBR inline unwinding check when unsupported Arnaldo Carvalho de Melo
2026-11-17 20:29   ` sashiko-bot

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=av1O-I_uLOoY0u5r@google.com \
    --to=namhyung@kernel.org \
    --cc=acme@kernel.org \
    --cc=acme@redhat.com \
    --cc=adrian.hunter@intel.com \
    --cc=irogers@google.com \
    --cc=james.clark@linaro.org \
    --cc=jolsa@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-perf-users@vger.kernel.org \
    --cc=mingo@kernel.org \
    --cc=tglx@linutronix.de \
    --cc=williams@redhat.com \
    /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.