The Linux Kernel Mailing List
 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
> 

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

Thread overview: 17+ 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:04 ` [PATCH v6 02/13] perf scripts: Add a coverage harness for perf Arnaldo Carvalho de Melo
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-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:04 ` [PATCH v6 05/13] perf tests: Exercise the flexible array member path Arnaldo Carvalho de Melo
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:04 ` [PATCH v6 07/13] perf tests: Exercise data type resolution from a register Arnaldo Carvalho de Melo
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:04 ` [PATCH v6 09/13] perf tests: Silence the libbfd probe in build-test Arnaldo Carvalho de Melo
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:04 ` [PATCH v6 11/13] perf tests: Fix the Intel PT virtual LBR check Arnaldo Carvalho de Melo
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:04 ` [PATCH v6 13/13] perf test: Skip the LBR inline unwinding check when unsupported Arnaldo Carvalho de Melo

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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox