mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Arnaldo Carvalho de Melo <acme@kernel.org>
To: Namhyung Kim <namhyung@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: [PATCH v11 08/19] perf test: Exercise the x86 operand parser
Date: Sun, 22 Nov 2026 18:40:14 -0300	[thread overview]
Message-ID: <20261122214025.16769-9-acme@kernel.org> (raw)
In-Reply-To: <20261122214025.16769-1-acme@kernel.org>

From: Arnaldo Carvalho de Melo <acme@redhat.com>

Add a unit test for x86 operand parsing.  The 64-bit absolute disp32
and movabs cases are from the allmodconfig clang build in the preceding
changes.  Also check a 32-bit absolute address, an immediate, and
values that should not become absolute addresses.  Both objdump
spellings of the movabs instruction must yield the KASAN shadow offset.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
 tools/perf/tests/Build          |   1 +
 tools/perf/tests/annotate-ops.c | 172 ++++++++++++++++++++++++++++++++
 tools/perf/tests/builtin-test.c |   1 +
 tools/perf/tests/tests.h        |   1 +
 4 files changed, 175 insertions(+)
 create mode 100644 tools/perf/tests/annotate-ops.c

diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 5eebb2ec5ddefcfd..c7edd8569bbccb06 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -2,6 +2,7 @@
 
 perf-test-y += builtin-test.o
 perf-test-y += tests-scripts.o
+perf-test-y += annotate-ops.o
 perf-test-y += parse-events.o
 perf-test-y += uncore-event-sorting.o
 perf-test-y += dso-data.o
diff --git a/tools/perf/tests/annotate-ops.c b/tools/perf/tests/annotate-ops.c
new file mode 100644
index 0000000000000000..766126fc2e2f5e98
--- /dev/null
+++ b/tools/perf/tests/annotate-ops.c
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * The x86 operand parser: what is a memory reference and where it points.
+ *
+ * The data type resolver follows absolute memory operands; an immediate
+ * is not a memory reference.
+ */
+#include <elf.h>
+#include <linux/compiler.h>
+#include <stdlib.h>
+#include <string.h>
+#include "annotate.h"
+#include "debug.h"
+#include "dso.h"
+#include "disasm.h"
+#include "tests.h"
+
+struct op_case {
+	const char		*insn;
+	const struct ins_ops	*ops;
+	const char		*operand;
+	bool			mem_ref;
+	int			offset;
+};
+
+static struct op_case op_cases[] = {
+	/* 32-bit absolute, and the 64-bit sign extended disp32 both ways */
+	{ "mov",    &mov_ops,  "0x8c73448",		true,  0x8c73448 },
+	{ "mov",    &mov_ops,  "0xffffffffff5fc300",	true,  -0xa03d00 },
+	{ "mov",    &mov_ops,  "-0xa03d00",		true,  -0xa03d00 },
+	/* An immediate is not a memory reference */
+	{ "mov",    &mov_ops,  "$0x10",			false, 0 },
+	/* Zero and values wider than a disp32 are not absolute addresses. */
+	{ "mov",    &mov_ops,  "0x0",			false, 0 },
+	{ "mov",    &mov_ops,  "0x100000000",		false, 0 },
+};
+
+static int check_operand(const struct arch *arch, const struct op_case *c,
+			 struct dso *dso64, struct dso *dso32, struct dso *dsorel)
+{
+	struct disasm_line dl = {
+		.ins = { .name = c->insn, .ops = c->ops },
+	};
+	struct annotated_insn_loc loc;
+	struct annotated_op_loc *op;
+	int ret = 0;
+
+	dl.ops.source.raw = (char *)c->operand;
+
+	if (annotate_get_insn_location(arch, &dl, &loc) < 0)
+		return TEST_FAIL;
+
+	op = &loc.ops[INSN_OP_SOURCE];
+	if (op->mem_ref != c->mem_ref) {
+		pr_debug("'%s %s': mem_ref %d, expected %d\n", c->insn,
+			 c->operand, op->mem_ref, c->mem_ref);
+		ret = TEST_FAIL;
+	}
+	if (op->mem_ref && op->offset != c->offset) {
+		pr_debug("'%s %s': offset %#x, expected %#x\n", c->insn,
+			 c->operand, op->offset, c->offset);
+		ret = TEST_FAIL;
+	}
+	if (c->mem_ref &&
+	    (!annotated_op_loc__is_abs(op, dso64) ||
+	     !annotated_op_loc__is_abs(op, dso32) ||
+	     annotated_op_loc__abs_addr(op, dso64) != (u64)(s64)c->offset ||
+	     annotated_op_loc__abs_addr(op, dso32) != (u32)c->offset)) {
+		pr_debug("'%s %s': wrong absolute address\n", c->insn, c->operand);
+		ret = TEST_FAIL;
+	}
+	/* The same operand in a relocatable object is an addend, not an address */
+	if (c->mem_ref && annotated_op_loc__is_abs(op, dsorel)) {
+		pr_debug("'%s %s': absolute address in a relocatable object\n",
+			 c->insn, c->operand);
+		ret = TEST_FAIL;
+	}
+
+	return ret;
+}
+
+struct movabs_case {
+	const char	*name;
+	const char	*operand;
+	s64		imm;
+};
+
+/* The KASAN shadow offset movabs, as both disassemblers print it */
+static const struct movabs_case movabs_cases[] = {
+	{ "movabsq", "$-0x2000040000000000, %r15 # imm = 0xDFFFFC0000000000",
+	  -0x2000040000000000LL },
+	{ "movabs",  "$0xdffffc0000000000,%r15", -0x2000040000000000LL },
+};
+
+static int check_movabs(const struct arch *arch, const struct movabs_case *c)
+{
+	struct disasm_line dl = { .ins = { .name = c->name } };
+	struct annotated_insn_loc loc;
+	int ret = TEST_FAIL;
+
+	dl.ops.raw = strdup(c->operand);
+	if (dl.ops.raw == NULL)
+		return TEST_FAIL;
+
+	dl.ins.ops = ins__find(arch, c->name, &dl);
+	if (dl.ins.ops != &mov_ops || dl.ins.ops->parse(arch, &dl.ops, NULL, &dl) < 0) {
+		pr_debug("'%s %s': not parsed as a mov\n", c->name, c->operand);
+		goto out;
+	}
+
+	/*
+	 * get_dwarf_regnum() is a stub returning -1 when perf is built
+	 * without libdw, the target register cannot be resolved then.
+	 */
+#ifdef HAVE_LIBDW_SUPPORT
+	if (annotate_get_insn_location(arch, &dl, &loc) == 0 &&
+	    !loc.ops[INSN_OP_SOURCE].mem_ref && loc.ops[INSN_OP_SOURCE].imm &&
+	    loc.ops[INSN_OP_SOURCE].imm_value == c->imm &&
+	    loc.ops[INSN_OP_TARGET].reg1 != -1)
+#else
+	if (annotate_get_insn_location(arch, &dl, &loc) == 0 &&
+	    !loc.ops[INSN_OP_SOURCE].mem_ref && loc.ops[INSN_OP_SOURCE].imm &&
+	    loc.ops[INSN_OP_SOURCE].imm_value == c->imm)
+#endif
+		ret = TEST_OK;
+	else
+		pr_debug("'%s %s': not an immediate to a register\n",
+			 c->name, c->operand);
+out:
+	free(dl.ops.source.raw);
+	free(dl.ops.target.raw);
+	free(dl.ops.raw);
+	return ret;
+}
+
+static int test__annotate_ops(struct test_suite *test __maybe_unused,
+			      int subtest __maybe_unused)
+{
+	struct e_machine_and_e_flags id = { .e_machine = EM_X86_64, };
+	const struct arch *arch = arch__new_x86(&id, NULL);
+	struct dso *dso64 = dso__new("annotate-ops-64");
+	struct dso *dso32 = dso__new("annotate-ops-32");
+	struct dso *dsorel = dso__new("annotate-ops-rel");
+	size_t i;
+	int ret = 0;
+
+	if (arch == NULL || dso64 == NULL || dso32 == NULL || dsorel == NULL) {
+		dso__put(dso64);
+		dso__put(dso32);
+		dso__put(dsorel);
+		free((void *)arch);
+		return TEST_FAIL;
+	}
+
+	dso__set_is_64_bit(dso64, true);
+	dso__set_is_64_bit(dso32, false);
+	dso__set_rel(dsorel, ET_REL);
+
+	for (i = 0; i < ARRAY_SIZE(op_cases); i++)
+		ret |= check_operand(arch, &op_cases[i], dso64, dso32, dsorel);
+
+	for (i = 0; i < ARRAY_SIZE(movabs_cases); i++)
+		ret |= check_movabs(arch, &movabs_cases[i]);
+
+	dso__put(dso64);
+	dso__put(dso32);
+	dso__put(dsorel);
+	free((void *)arch);
+	return ret;
+}
+
+DEFINE_SUITE("Annotate operand parsing", annotate_ops);
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 01c78ef20b97dec9..a27baf3a819ccf36 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -117,6 +117,7 @@ static struct test_suite *generic_tests[] = {
 	&suite__openat_syscall_event_on_all_cpus,
 	&suite__basic_mmap,
 	&suite__mem,
+	&suite__annotate_ops,
 	&suite__parse_events,
 	&suite__uncore_event_sorting,
 	&suite__expr,
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index af822885890dda73..963cb34acd345153 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -153,6 +153,7 @@ DECLARE_SUITE(sample_parsing);
 DECLARE_SUITE(keep_tracking);
 DECLARE_SUITE(parse_no_sample_id_all);
 DECLARE_SUITE(dwarf_unwind);
+DECLARE_SUITE(annotate_ops);
 DECLARE_SUITE(expr);
 DECLARE_SUITE(hists_filter);
 DECLARE_SUITE(mmap_thread_lookup);
-- 
2.56.1


  parent reply	other threads:[~2026-11-22 21:41 UTC|newest]

Thread overview: 20+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-22 21:40 [PATCH v11 00/19] perf coverage: A harness for perf, and the fixes it found Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 01/19] perf build: Link the GTK UI with EXTRA_CFLAGS Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 02/19] perf annotate: Handle absolute addressing in data type profiling Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 03/19] perf annotate: Print the stats after the annotations Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 04/19] perf build: Record the features checked outside FEATURE_TESTS Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 05/19] perf annotate-x86: Record immediates in a 64-bit field Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 06/19] perf annotate-x86: Parse movabs like a mov Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 07/19] perf annotate-data: Count flexible array accesses for the whole struct Arnaldo Carvalho de Melo
2026-11-22 21:40 ` Arnaldo Carvalho de Melo [this message]
2026-11-22 21:40 ` [PATCH v11 09/19] perf test: Exercise DW_OP_addrx global variables Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 10/19] perf test: Exercise the flexible array member path Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 11/19] perf test: Exercise data type resolution from a register Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 12/19] perf test: Exercise the annotate stats output Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 13/19] perf test: Fix the Intel PT virtual LBR check Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 14/19] perf test: Drop samples without an IP in the dlfilter test Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 15/19] perf test: Skip the LBR inline unwinding check when unsupported Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 16/19] perf test: Skip the trace summary BPF tests without kernel BTF Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 17/19] perf test: Avoid online CPUs in the offline stat test Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 18/19] perf scripts: Add a coverage harness for perf Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 19/19] perf scripts: Add a coverage table 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=20261122214025.16769-9-acme@kernel.org \
    --to=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=namhyung@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

all inboxes | Powered by JetHome®